Scala Future flatMap implementation (chaining)

Question

Trying to wrap my head around how async tasks are chained together, for ex futures and flatMap

val a: Future[Int] = Future { 123 }
val b: Future[Int] = a.flatMap(a => Future { a + 321 })

How would i implement something similar where i build a new Future by waiting for a first and applying a f on the result. I tried looking a scala's source code but got stuck here: https://github.com/scala/scala/blob/2.13.x/src/library/scala/concurrent/Future.scala#L216

i would imagine some code like:

def myFlatMap(a: Future[Int])(f: a => Future[Int]): Future[Int] = {
   Future {
      // somehow wait for a to complete and the apply 'f'
      a.onComplete {
        case Success(x) => f(a)
      }
   }
}

but i guess above will return a Future[Unit] instead. I would just like to understand the "pattern" of how async tasks are chained together.

question from:https://stackoverflow.com/questions/66052233/scala-future-flatmap-implementation-chaining

Answer 1

(Disclaimer: I'm the main maintainer of Scala Futures)

You wouldn't want to implement flatMap/recoverWith/transformWith yourself—it is a very complex feature to implement safely (stack-safe, memory-safe, and concurrency-safe).

You can see what I am talking about here:

• https://github.com/scala/scala/blob/2.13.x/src/library/scala/concurrent/impl/Promise.scala#L442
• https://github.com/scala/scala/blob/2.13.x/src/library/scala/concurrent/impl/Promise.scala#L307
• https://github.com/scala/scala/blob/2.13.x/src/library/scala/concurrent/impl/Promise.scala#L274

There is more reading on the topic here: https://viktorklang.com/blog/Futures-in-Scala-2.12-part-9.html