Esegui Scala Futures in una serie dopo l'altra

Question

Dato un metodo che restituisce un Future come questo ...

def myMethod(name: String, count: Int, default: Boolean): Future[Unit] = { 
    ... 
} 

... ho bisogno di invocarlo N volte, così ho definito una lista di tuple contenenti i parametri da passare:

val paramList = List(
    ("text1", 22, true), 
    ("text2", 55, true), 
    ("text3", 77, false) 
) 

Come invoco myMethod con Future.traverse?

Future.traverse(paramList)(myMethod _).tupled(/* how do I pass the current tuple here? */) 

Answer 1

Due possibili approcci:

val futuresFromSequence: Future[List[Unit]] = Future.sequence(paramList.map { 
    case (a,b,c) => myMethod(a,b,c) 
}) 

val futuresFromTraverse: Future[List[Unit]] = Future.traverse(paramList)(x => x match { 
    case(a,b,c) => myMethod(a,b,c) 
}) 

Nota che traverse richiede un po 'di raccolta e una funzione da un elemento di tale raccolta ad un futuro, sequence prende invece un elenco di futures e pieghe in un futuro di lista.

Se si vuole rimanere con il tupled sintassi (che io personalmente non piace):

Future.traverse(paramList)(x => (myMethod _).tupled(x)) 

Come notato nei commenti si consiglia di eseguirli in serie (anche se non è chiaro al 100% dalla questione), in questo caso è possibile utilizzare foldLeft e flatMap a catena di esecuzione futuro:

myList.foldLeft(Future(List.empty[Unit]))((prevFuture, currentTuple) => { 
    for { 
    prev <- prevFuture 
    curr <- (myMethod _).tupled(currentTuple) 
    } yield prev :+ curr 
}) 

dove in sostanza il primo generatore attende per il futuro nell'accumulatore per completare prima di lanciare il nuovo, anche questo restituisce un Future[List[Unit]].