scala-option

Using Scala 2.7.7: If I have a list of Options, I can flatten them using a for-comprehension: val listOfOptions = List(None, Some("hi"), None) listOfOptions: List[Option[java.lang.String]] = List(None, Some(hi), None) scala> for (opt <- listOfOptions; string <- opt) yield string res0: List[java.lang.String] = List(hi) I don't like this style, and would rather use a HOF. This attempt is too verbose to be acceptable: scala> listOfOptions.flatMap(opt => if (opt.isDefined) Some(opt.get) else None) res1: List[java.lang.String] = List(hi) Intuitively I would have expected the following to work, but

I wonder why scala.Option doesn't have a method fold like this defined: fold(ifSome: A => B , ifNone: => B) equivalent to map(ifSome).getOrElse(ifNone) Is there no better than using map + getOrElse ? Debilski You can do: opt foldLeft (els) ((x, y) => fun(x)) or (els /: opt) ((x,y) => fun(x)) (Both solutions will evaluate els by value, which might not be what you want. Thanks to Rex Kerr for pointing at it.) Edit: But what you really want is Scalaz’s catamorphism cata (basically a fold which not only handles the Some value but also maps the None part, which is what you described) opt.cata(fun,

Is there a predefined function x in Scala that combine 2 Options so that Some(a) x None => Some(a) None x Some(b) => Some(b) None x None => None Yes, this is the orElse method. It chooses the first defined value, or None if neither is defined. scala> Some(1) orElse None res0: Option[Int] = Some(1) scala> None orElse Some(1) res1: Option[Int] = Some(1) scala> None orElse None res2: Option[Nothing] = None scala> Some(1) orElse Some(2) res3: Option[Int] = Some(1) In the question comments, you mention you can't have Some(a) and Some(b) , so what you really have is Option[Either[Int,Int]] . In that

I'm starting to explore Scala, and one of the things I'm intrigued by is the Option type and the promise of being able to eliminate null related errors. However I haven't been able to work out how to transform a list (or other collection) of, say, Option[String] , to a collection of String (obviously filtering out any values that are None ). In other words, how do I get from this: List[Option[Int]] = List(Some(1)) ... to this: List[Int] = List(1) I'm using Scala 2.8 if that has any impact on the answer. val list1 = List(Some(1), None, Some(2)) val list2 = list1.flatten // will be: List(1,2)

Why does this construction cause a Type Mismatch error in Scala? for (first <- Some(1); second <- List(1,2,3)) yield (first,second) <console>:6: error: type mismatch; found : List[(Int, Int)] required: Option[?] for (first <- Some(1); second <- List(1,2,3)) yield (first,second) If I switch the Some with the List it compiles fine: for (first <- List(1,2,3); second <- Some(1)) yield (first,second) res41: List[(Int, Int)] = List((1,1), (2,1), (3,1)) This also works fine: for (first <- Some(1); second <- Some(2)) yield (first,second) For comprehensions are converted into calls to the map or