/ / Wygodny sposób na wykonywanie leniwych kontraktów futures, które są zawarte w głównej przyszłości - scala

Wygodny sposób na wykonywanie leniwych kontraktów futures, które są zawarte w głównej przyszłości - scala

Jest następująca sytuacja:

type LazyFuture = () => Future

val mainFuture: Future[Seq[LazyFuture]] = Future {
...
// some actions which can throw exceptions
...

// inner lazy futures as result of main future
// they has to be executed only if the main future is completed successfully
val xs: Seq[LazyFuture] = Seq(
() => Future(1),
() => Future(2),
...
() => Future(N)
)
xs
}

Czy istnieje wygodny sposób na wykonanie wewnętrznej lazy futures w przypadku, gdy mainFuture jest pomyślnie wykonany. Poniższe pseudo ilustruje zadanie:

val resultFuture:Future[Any] =
if(mainFuture is success)
// exec inner lazy futures
Future.sequence(mainFuture.result.map(c => c()))
else
// nothing
Future.successful(Unit)

Odpowiedzi:

0 dla odpowiedzi № 1

Znalazłem następujące rozwiązanie dla powyższego zadania.

type LazyFuture = () => Future

val mainFuture: Future[Seq[LazyFuture]] = Future {

val xs: Seq[LazyFuture] = Seq(
() => Future(1),
() => Future(2),
...
() => Future(N)
)
xs
}

val promise = Promise[Future[Seq[Any]]]()

mainFuture.onComplete {
case Success(xs: Seq[LazyFuture]) =>
val eventualSeq: Future[Seq[Any]] = Future.sequence(xs.map(c => c()))
promise success eventualSeq
case Failure(t) => promise failure t
}

val resultFuture: Future[Any] = promise.future.flatten

Czy to rozwiązanie jest wystarczająco dobre i czy mogą pojawić się jakieś problemy?