私はHashMapを変換しますか[T、フューチャー[N]]フューチャー[HashMapの[T、N]]

Question

は私が

Future.sequence 

がList[Future[T]]Future[List[T]]

に変換するために存在することを知っているにHashMap[T,Future[N]]をFuture[HashMap[T,N]]に変換する方法はありますか？

Answer 1

例えば、あり、このための標準ライブラリに組み込まれたものではありませんが、それが実現するのは簡単です

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 
      } 
    } 
} 

（私は明確にするため上記のいくつかの余分な不要な型注釈を追加しました。）

Answer 2

ないアウトオブボックスの機能について確認してください、私はこのようにそれを自分自身にしてください：

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：

ない質問の主なポイント、しかし、不変のマップの代わりに変更可能なHashMapが必要な場合は、それを変換する必要があります。ここでは、おそらくよりよい何かがあります、私の頭の上から醜いっぽい方法です：

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