scala How to wait for several Futures - scala

Question

I have seq
i want to do the iterate automatic

Answer 1

You could use iterator with flatMap. Here is a simplified example:
import scala.concurrent.Await
import scala.concurrent.Future
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
val functions: Seq[() => Future[Int]] = Seq(
() => Future(1),
() => Future(2),
() => Future(3),
() => Future(4),
() => Future(5)
)
def checkResult(result: Int): Boolean = result > 3
functions.iterator.flatMap { func =>
val result = Await.result(func(), 5.seconds)
if (checkResult(result)) Some(result) else None
}.next()
This code would return 4.
Update:
If you just care about the correct result and don't care whether or not all futures get executed, you could chain them with fallBackTo:
import scala.util._
functions.tail.foldLeft[Future[Int]](functions.head().filter(checkResult)) {
case (result, function) =>
result.fallbackTo(function().filter(checkResult))
}.onComplete {
case Success(result) => s"Got one: $result"
case Failure(exception) => s"Damn! Got NO result due to: $exception"
}
This would give you a Future that would complete with Success(4) with my example predicate x > 3.
UPDATE 2
As I found myself with some extra time, I took the liberty to combine some comments and suggestions in other answers (especially from Alexander Azarov) with a loan pattern approach:
import scala.annotation.tailrec
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
val functions: Seq[() => Future[Int]] = Seq(
() => Future(1),
() => Future(2),
() => Future(3),
() => Future(4),
() => Future(5)
)
def checkResult(result: Int): Boolean = result > 5
def withFirstValidResult[A, B](futureFuncs: Seq[() => Future[A]], predicate: A => Boolean, defaultValue: A)(op: (A) => B): Future[B] = {
#tailrec
#inline def find(remaining: Iterator[Future[A]]): Future[A] = {
if (remaining.hasNext) {
remaining.next().filter(predicate).recoverWith {
case _ =>
find(remaining)
}
} else {
Future.successful {
println(s"No valid result found, falling back to default: $defaultValue")
defaultValue
}
}
}
find(futureFuncs.iterator.map(_())).map(op)
}
You can now use this function with any kind of futures you want and provide an operation that should be executed with the first valid result or the defaultValue (though IMHO in case of no valid result I'd prefer a Failure with proper error handling myself):
withFirstValidResult(functions.iterator, checkResult, 0) { result =>
println(s"Got a valid result: $result")
}.onFailure {
case ex =>
println(s"Got NO valid result: $ex")
}
As an extra tip, if you want to speed up the function you can have the iterator lazily evaluate two functions at a time with futureFuncs.iterator.buffered. This way, while one future result is being evaluated, the iterator will automatically start the next future.

Answer 2

def firstF[A](seq: Seq[() => Future[A]], predicate: A => Boolean): Future[A] =
seq.head().filter(predicate).recoverWith {
case _ => firstF[A](seq.tail, predicate)
}
Method firstF will return the first Future that matches the condition specified. The resulting Future will be a Failure if none of the input Futures match. To return some default value otherwise, you would simply do
firstF(seq, predicate).recover { case _ => default }
Note 1 the code here demonstrates basic principles and does not distinguish between planned or unplanned exceptions.
Note 2 this code is not tail-recursive.

Answer 3

import scala.concurrent.{Await, Future}
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
def f(x:String) = Future { x }
val functions = Seq(
() => f("a"),
() => f("b"),
() => f(""),
() => f("d"),
() => f("e"))
functions.takeWhile( x => Await.result(x(), 5 seconds) != "")
This will give you
res0: Seq[() => scala.concurrent.Future[String]] = List(<function0>, <function0>)
Iam not sure if there is another approach but for my understanding if you want to decide based on the result of the preceeding future you need to wait.
EDIT:
Here is a recursive approach. But in my opinion the one with the iterator is good.
import scala.concurrent.{Await, Future}
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
def f(x:String) = Future { x }
val functions = Seq(
() => f("a"),
() => f("b"),
() => f(""),
() => f("d"),
() => f("e"))
check(functions, 0)
def check(list:Seq[() => Future[String]], pos:Int):String = {
if(list.size <= pos) return ""
val res = Await.result(list(pos)(), 5 seconds)
if(condition(res)) {
res
}
else check(list, pos+1)
}
def condition(c:String):Boolean = if(c == "d") true else false
It's tail recursive therefore your stack won't overflow that easy.