Scala, führen Karte von Futures

Question

Was ist der beste Weg ist

Map[String, Future[A]] 

zu

Map[String, A] 

zu gehen, wo A das Ergebnis der entsprechenden Zukunft der Ausführung ist?

Dies wird nicht kompilieren:

val results = for { 
    (key, future) <- myMap 
    result <- future 
} yield (key, result) 

, da ich nicht Futures und Iterables im gleichen für das Verständnis mischen.

Answer 1

Wenn Sie es in eine Seq[Future[(String,A)]] konvertieren, können Sie dann Future.fold verwenden, um es einen einzigen Future[Map[...]] zurück:

def transform[A](m: Map[String, Future[A]]): Future[Map[String, A]] = { 
    val seq: Seq[Future[(String, A)]] = m.toSeq.map { case (key, f) => 
    f.map(i => key -> i) 
    } 

    Future.fold(seq)(Map.empty[String, A])(_ + _) 
} 

dann die einzige Zukunft als normal einlösen.

Answer 2

So etwas wie dies vielleicht:

map.mapValues { Await.result(_, 5 seconds) } 

Answer 3

Dima gab bereits eine Antwort mit Await. Es wird jedoch eine Ausnahme auslösen, wenn die Zukunft fehlschlägt.

Sie können die Typen weiter einbetten als Try und dann eine .collect, um nur für die erfolgreichen Futures zu filtern (überprüfen Sie die offizielle API dafür).

import scala.util.{ Try, Success } 

val results = myMap 
    .map { 
     case (key, value) => key => Try(Await.result(value, 5.seconds)) 
    } 
    .collect { 
     case (key, Success(value)) => key -> value 
    } 

Mit dem obigen Aufruf verwerfen Sie automatisch fehlgeschlagene Futures und sammeln nur erfolgreiche.