Future[Option[Future[Int]]] to Future[Option[Int]]

Question

What is the cleanest way in Scala to convert from Future[Option[Future[Int]]] to Future[Option[Int]]? Is it even possible?

If you ever decide to go the scalaz route, this is the kind of thing that monad transformers are good for. I think `OptionT[Task, Int]` would help you here. Related: http://stackoverflow.com/a/14386670/402884 — Chris Martin, Aug 11 '15 at 03:19

Chris Martin · Accepted Answer · 2015-09-05T07:18:51.393

There are two nested Futures that you roll into one, so this calls for a flatMap.

def flatten[A](f: Future[Option[Future[A]]]): Future[Option[A]] =
  f.flatMap({
    case None => Future.successful(None)
    case Some(g) => g.map(Some(_))
  })

Or, more concisely:

def flatten[A](f: Future[Option[Future[A]]]): Future[Option[A]] =
  f.flatMap(o => Future.sequence(o.toSeq).map(_.headOption))

Thanks to @lmm's answer for the idea on that. Ideally this could be written as f.flatMap(Future.sequence), but unfortunately sequence expects a TraversableOnce, which Option does not extend.

score 1 · Answer 2 · edited Mar 20 '18 at 11:57

1

The cleanest way is probably using scalaz:

import scalaz.std.option._
import scalaz.std.scalaFuture._
import scalaz.syntax.traverse._

//assuming implicit execution context in scope

f.flatMap(_.sequence)

edited Mar 20 '18 at 11:57

Community

1
1

answered Sep 03 '15 at 09:50

lmm

17,386
3
26
37

score 0 · Answer 3 · edited May 23 '17 at 11:52

You are asking how to code your way out of some paper bag, and you have gotten some good answers about how to do this, however you should be stepping back and trying to just not get into the paper bag you are currently in. See my answer here: Get rid of Scala Future nesting about how to avoid getting into a Future[X[Future[y]] type signature so that you don't have to figure out how to then get out of it.

Future[Option[Future[Int]]] to Future[Option[Int]]

3 Answers3