Type mis-match after flattening a Some(Option) in fold function

Question

I want to get the product of a List[Option[Int]], and flatten it to Option[Int]:

List(Some(2), Some(3), Some(5)).foldLeft(Some(1)) { (x, y) =>

  // err
  x.map(ix => y.map(iy => ix * iy)).flatten

  //   // workaround
  //   x.map(ix => y.map(iy => ix * iy)).flatten match {
  //    case Some(acc) => Some(acc)
  //     case _ => Some(0)
  //   }

}

the err in detail:

polymorphic expression cannot be instantiated to expected type;
[error]  found   : [B]Option[B]
[error]  required: Some[Int]
[error]       x.map(ix => y.map(iy => ix * iy)).flatten 
[error]

flatten in foldLeft didn't return Some[Int]? What's going on?

mohit · Accepted Answer · 2015-05-26T06:35:10.920

2

x.map(ix => y.map(iy => ix * iy)).flatten

returns an Option[Int], based on the value of the x and y, i.e. if either x or y is None the value is None, otherwise it is Some[Int].

In your fold statement, your seed value is Some(1) whose type is Some[Int]. Compiler expects the same type from the result of the fold statement. But the result value of the expression of the fold statement is Option[Int]. Hence, the error, the required type is Some[Int] as of the seed value, but compiler found Option[Int] from the fold expression.

Any of the other answer works. The closet to your expression will be simply change your seed value to Option(1) from Some(1), so that the type of seed value and type from the fold statement matches, like

List(Some(2), Some(3), Some(5)).foldLeft(Option(1)) { (x, y) => ....

edited May 26 '15 at 06:35

answered May 26 '15 at 06:30

mohit

4,968
1
22
39

Thanks. Btw, what does the `[error] found : [B]Option[B]` mean? esp. the [B] before Option[B]? – maow May 26 '15 at 06:38
@maow - Sorry, but I don't know. Scala compiler goes through lots of hoops to make things work with JVM and also to preserve type-safety. Sometimes the internal implementation of the clever technology that makes things work leaks into the errors/type signatures in the scala library. I usually take scala errors with a pinch of salt, rather than on its face value – mohit May 26 '15 at 06:50

score 1 · Answer 2 · edited May 23 '17 at 11:51

If your list is actually a List[Option[Int]] then for a working example you need to declare them as such. It would be great if someone could chime in on exactly why since I'm not sure.

val xs = List(Option(2), Option(3), Option(5))

xs.reduceRight((x, b) => x.flatMap(y => b.map(z => y * z)))
// res0: Option[Int] = Some(30)

Note however if any element in the list of Options is None then the evaluation will "short circuit" and return a None. If you don't want this then I believe you will need to look at some solutions from scalaz such as applicative functors, there's some discussion this here Summing a List of Options with Applicative Functors

score 0 · Answer 3 · answered May 26 '15 at 06:24

0

This works and is simpler:

List(Some(2), Some(3), Some(5)).flatten.foldLeft(1) { (x, y) => x * y}

Flattten removes Nones and gives you List[Int].

answered May 26 '15 at 06:24

Waldemar Wosiński

1,490
17
28

1

This is a better answer. Also, IntelliJ hinted that you can replace the entire foldLeft function with `.product`. So it would be `List(..).flatten.product` – goralph May 26 '15 at 06:39
This is a better solution, but not what I asked. Sorry didn't make it clear, the precondition was operations should be taken on Option[Int]. – maow May 26 '15 at 06:57

Type mis-match after flattening a Some(Option) in fold function

3 Answers3