Scala pattern matching with async or future - scala

Question

Example code snippet :
def evalExpr(e: Expr): Int = e match {
case Num(n) => n
case Sum(l, r) => evalExpr(l) + evalExpr(r)
case Prod(l, r) => evalExpr(l) * evalExpr(r)
}
What would be the best way to implement pattern matching where evalExpr runs asynchronously?

Answer 1

You can Wrap them in Scala's Futures :
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
trait Expr
case class Num(n:Int) extends Expr
case class Sum(n:Expr,m:Expr) extends Expr
case class Prod(n:Expr,m:Expr) extends Expr
def evalExpr(e: Expr): Future[Int] = e match {
case Num(n) => Future(n)
case Sum(l, r) =>
val exp1 = evalExpr(l)
val exp2 = evalExpr(r)
for{
i<-exp1
j<-exp2
} yield i + j
case Prod(l, r) =>
val exp1 = evalExpr(l)
val exp2 = evalExpr(r)
for{
i<-exp1
j<-exp2
} yield i + j
}
evalExpr(Prod(Sum(Num(1),Prod(Num(3),Num(2))),Num(2))).map(println)
scala> evalExpr(Prod(Sum(Num(1),Prod(Num(3),Num(2))),Num(2))).map(println)
8 // As you can see output of the calculation is asynchronously printed.
res0: scala.concurrent.Future[Unit] = scala.concurrent.impl.Promise$DefaultPromise#65039982

Answer 2

If the evalExpr(Expr) would return Future[Int] you would write for instance Prod(l, r) like this:
case Prod(l, r) => {
val eval1 = evalExpr(l)
val eval2 = evalExpr(r)
for {
left <- eval1
right <- eval2
} yield left*right
}
This would combine the two futures - left and right - together and return new future.
Using futures also the case Num(n) should be => Future(n).