Come compongo un elenco di `Futures`?

Question

Ho una collezione di Promises. Stavo cercando un modo efficace per comporre lo Futures risultante. Attualmente il modo più pulito ho trovato di combinarli è stato quello di utilizzare uno scalaz Monoid, in questo modo:

val promises = List(Promise[Unit], Promise[Unit], Promise[Unit]) 

    promises.map(_.future).reduce(_ |+| _).onSuccess { 
    case a => println(a) 
    } 

    promises.foreach(_.success(())) 

C'è un modo pulito per fare questo che non richiede scalaz?

Il numero di Futures nella raccolta varierà e molte raccolte intermedie non sono desiderabili.

Answer 1

Si potrebbe utilizzare Future.traverse:

import scala.concurrent.ExecutionContext.Implicits.global 
import scala.concurrent.{ Future, Promise } 

val promises = List(Promise[Unit], Promise[Unit], Promise[Unit]) 
Future.traverse(promises)(_.future) 

Questo vi darà una Future[List[Unit]], che non esattamente si qualifica come "un sacco di collezioni intermedi", ma non è necessariamente l'ideale, sia. Future.reduce funziona anche:

Future.reduce(promises.map(_.future))((_, _) =>()) 

Questo restituisce una Future[Unit] che sarà soddisfatta quando tutti i future sono soddisfatti.

Answer 2

Future.sequence è il metodo che si desidera.