Wie verwandeln ich eine HashMap [T, Zukunft [N]] Future [HashMap [T, N]]

Question

Ich weiß, dass es

Future.sequence 

existiert ein List[Future[T]] auf ein Future[List[T]]

zu transformieren Gibt es eine Möglichkeit, eine HashMap[T,Future[N]] zu Future[HashMap[T,N]] zu transformieren?

Answer 1

Es gibt nichts in die Standardbibliotheken für diese gebaut, aber es ist einfach genug, um zu implementieren, beispielsweise

def combineFutures[K,V](m: Map[K,Future[V]]): Future[Map[K,V]] = { 
    m.foldLeft(Future.successful(Map.empty[K, V])) { 
     case (futureAcc: Future[Map[K, V]], (k: K, futureV: Future[V])) => 
      for { 
       acc <- futureAcc 
       v <- futureV 
      } yield acc + (k -> v) 
    } 
} 

// Mutable HashMap version 
import scala.collection.mutable.HashMap 
def combineFutures[K,V](m: HashMap[K,Future[V]]): Future[HashMap[K,V]] = { 
    m.foldLeft(Future.successful(HashMap.empty[K, V])) { 
     case (futureAcc: Future[HashMap[K, V]], (k: K, futureV: Future[V])) => 
      for { 
       acc <- futureAcc 
       v <- futureV 
      } yield { 
       acc.put(k, v) 
       acc 
      } 
    } 
} 

(Ich habe einige zusätzliche unnötige Typenannotationen oben für Klarheit hinzugefügt.)

Answer 2

Nicht sicher eine out-of-the-Box-Funktion, aber ich würde es selbst tun, wie folgt:

import scala.collection.mutable.HashMap 
import scala.concurrent.Future 
import scala.concurrent.ExecutionContext.Implicits.global 

val a: HashMap[Int, Future[Int]] = HashMap((1, Future(42)), (2, Future(43))) 
val iterOfFutures = a.map { case (k, v) => v.map(vv => (k, vv)) } 
val futureMap: Future[Map[Int, Int]] = Future.sequence(iterOfFutures).map(_.toMap) 

futureMap.map(println) // Map(2 -> 43, 1 -> 42) 
Thread.sleep(100) 

EDIT:

nicht der Hauptpunkt der Frage, Aber wenn Sie eine veränderbare HashMap anstelle einer unveränderlichen Map möchten, müssen Sie sie konvertieren. Hier ist eine hässlich-ish Art und Weise aus der Spitze von meinem Kopf, vielleicht gibt es etwas schönere:

val futureMap: Future[HashMap[Int, Int]] = 
    Future.sequence(iterOfFutures).map(s => HashMap(s.toSeq: _*))