Mixing in asynchronous code within plain synchronous flow in Scala

Question

What is in your view the best scala solution for the case that you have some plain chain of synchronous function calls, and you need to add an asynchronous action in the middle of it without blocking?

I think going for futures entails refactoring existing code to callback spaghetti, tethering futures all the way through the formerly synchronous chain of function calls, or polling on the promise every interval, not so optimal but maybe I am missing some trivial/suitable options here.

It may seem that refactoring for (akka) actors, entail a whole lot of boilerplate for such a simple feat of engineering.

How would you plug in an asynchronous function within an existing synchronous flow, without blocking, and without going into a lot of boilerplate?

Right now in my code I block with Await.result, which just means a thread is sleeping...

What do you want to do with the result of the asynchronous call? — Michael Zajac
Thanks for asking. Check its value for downstream processing, not a fire-and-forget — matanster

flavian flavian · Accepted Answer · 2015-03-04T19:14:02

One simple dirty trick:

Let's say you have:

def f1Sync: T1
def f2Sync: T2
...
def fAsynchronous: Future[TAsync]


import scala.concurrent.{ Future, Promise }


object FutureHelper {
  // A value class is much cheaper than an implicit conversion.
  implicit class FutureConverter[T](val t: T) extends AnyVal {
    def future: Future[T] = Promise.successful(t).future
  }

}

Then you can for yield:

import FutureHelper._

def completeChain: Future[Whatever] = {
  for {
    r1 <- f1Sync.future
    r2 <- f2Sync.future
    .. all your syncs
    rn <- fAsynchronous // this should also return a future
    rnn <- f50Sync(rn).future// you can even pass the result of the async to the next function
  } yield rn  
}

There is minimal boilerplate of converting your sync calls to immediately resolved futures. Don't be tempted to do that with Future.apply[T](t) or simply Future(a) as that will put daemon threads onto the executor. You won't be able to convert without an implicit executor.

With promises you pay the price of 3, 4 promises which is negligible and you get what you want. for yield acts as a sequencer, it will wait for every result in turn, so you can even do something with your async result after it has been processed.

It will "wait" for every sync call to complete as well, which will happen immediately by design, except for the async call where normal async processing will be automatically employed.

Mixing in asynchronous code within plain synchronous flow in Scala

2 Answers