Dependent futures

Question

Starting playing with Scala futures, I get stuck with dependent futures.

Let's get a example. I search for places and get a Future[Seq[Place]] . For each of theses places, I search for the closest subway stations (the service resurns a Future[List[Station]] ).

I would write this:

Place.get()
.map { places =>
    places.map { place =>
        Station.closestFrom(place).map { stations =>
            SearchResult(place, stations)
        }
    }
}

That thing will make me get a Future[Seq[Future[SearchResult]]] ... which is... not what I would have expected.

What did I miss to get a Future[Seq[SearchResult]] ?

Thanks for all,

Alban

Answer 1

You are missing two Future concepts in your solution: flatMap and Future.sequence

To explain each:

flatMap is like map except instead of giving it a function from future.map(A => B) you give it a function from future.flatMap(A => Future[B]) . This way you can chain Futures together.

Future.sequence is a helper function that combines a list of futures to a future of a list: Seq[Future[A]] => Future[Seq[A]]

Using these two features of the Future API we can change your answer to be:

Place.get().flatMap { places =>
    Future.sequence(places.map { place =>
        Station.closestFrom(place).map { stations =>
            SearchResult(place, stations)
        }
    })
}

Answer 2

Short version

Working with futures is generaly easier using for-comprehension rather than directly map/flatMap. In your situation it should look like this:

for {places        <- Place.get()
     searchResults <- Future.traverse(places)(place => for (stations <- Station.closestFrom(place))
                                                       yield SearchResult(place,stations)
                                              )
} yield searchResults

Detailed Version

Future being a monad, it offers you several ways to chain your operations.

• If you want to apply an 'regular' function f : A => B to what's inside the box myfuture : Future[A] , indeed map is the way to get a Future[B] . But in the present situation Station.closestFrom a does not give you a List[Stattion] but a Future[List[Station]] .
• If you want to apply a monadic operation h : A => Future[B] or chain several of them (here Places.get and Station.closestFrom ), flatMap is the way to go. Apply h to a Future[A] gives you a Future[B] .
• If you want to apply a monadic operation h : A => Future[B] to a collection like a places : Seq[A] , you should use Future.traverse : Seq[A] => (A => Future[B]) => Future[Seq[B]] .

Furthermore, Scala's for-compresention is just syntactic sugar for flatMap/map so instead of writing complex code using those directly you can use a clean and clear for loop. The loop:

for { variable1 <- f1
      variable2 <- f2
} yield expression

is equivalent to (without optimisations) :

f1.flatMap( variable1 => f2.map(variable2 => expression))

Don't hesitate to use for-comprehension, it really helps.