scala futures - comment obtenir le résultat ou l'échec des deux futurs

Avec for-comprehensions, dès qu'une ligne échoue, le code s'arrête juste là et toute exception est levée. Si r1 lance un Throwable, r2 ne sera jamais touché en premier lieu.

Personnellement, je les jetterais tous les deux dans un Soit [Throwable, peu importe] , plutôt que de mettre chaque .recoverWith dans un Future.Failed (...) . De cette façon, plutôt que de simplement faire un onFailure , vous pouvez faire quelque chose avec toutes les valeurs Left que vous obtenez et faire autre chose avec toutes les valeurs Right que vous obtenez . Ou vous pouvez utiliser Try / Success / Failure ... Cela dépend de ce que vous voulez faire avec les erreurs.

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.util.{Failure, Success, Try}

val f1 = Future(Try(1 / 1))
val f2 = Future(Try(1 / 0))

// for-comprehensions won't fall over when reading a Failure
// as failures don't extend Throwable
val combinedResult = for {
  r1 <- f1 // Success(1)
  r2 <- f2 // Failure(java.lang.ArithmeticException: / by zero)
} yield List(r1,r2)

combinedResult.map { // get inside Future
  f =>
    f.map { // get inside List
      case Success(a) => // do something with success
      case Failure(e: IndexOutOfBoundsException) => // do something with failure
      case Failure(e: ArithmeticException) => // do something with failure
      case Failure(e) => // do something with failure
    }
}

L'utilisation de flatMap sur Future [A] n'aidera pas, car elle sera toujours court-circuitée lors du premier échec produit par l'un d'entre eux, là où vous voulez vraiment accumuler les erreurs.

Une solution utilisant Future.traverse qui fonctionnera sur de nombreuses instances Future [A] arbitraires:

Oh no, err: TaggedException$3: 42
Received num: 42

Nous pouvons également utiliser un peu d'aide des chats avec son type Validé :

import cats.data.Validated.{Invalid, Valid}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration.Duration
import scala.concurrent.{Await, Future}
import cats.implicits._
import scala.util.{Failure, Success}

def main(args: Array[String]): Unit = {
  case class TaggedException(context: String, throwable: Throwable)
    extends Exception(throwable.getMessage)

  val f1 = Future.failed[Int](new Exception("42")).recoverWith {
    case e: Throwable => Future.failed(TaggedException("first one failed", e))
  }

  val f2 = Future(42).recoverWith {
    case e: Throwable => Future.failed(TaggedException("second one failed", e))
  }

  val res: Future[List[Validated[Throwable, Int]]] = 
    List(f1, f2)
     .traverse(eventualInt => eventualInt
                       .map(i => Valid(i))
                       .recover { case err => Invalid(err) })

  res.onComplete {
    case Failure(exception) =>
      println(exception)
    case Success(value) =>
      value.foreach {
        case Valid(int) => println(s"Received num: $int")
        case Invalid(err) => println(s"Oh no, err: $err")
      }
  }

  Await.result(res, Duration.Inf)
}

Donnera:

val f1 = Future.failed[Int](new Exception("42")).recoverWith {
  case e: Throwable => Future.failed(TaggedException("first one failed", e))
}

val f2 = Future(42).recoverWith {
  case e: Throwable =>
    Future.failed(TaggedException("second one failed", e))
}

val res: Future[List[Either[Throwable, Int]]] = 
  Future
   .traverse(List(f1, f2)) {
      eventualInt => eventualInt
       .map(i => Right(i))
       .recover { case err => Left(err) }
   }

res.onComplete {
  case Failure(exception) =>
    println(exception)
  case Success(value) =>
    value.foreach {
      case Right(int) => println(s"Received num: $int")
      case Left(err) => println(s"Oh no, err: $err")
    }
}

Await.result(res, Duration.Inf)

~~ Tout d'abord, vous ne dirigez pas vos futurs en parallèle (pour-compréhension les exécutera séquentiellement).~~

Mettre à jour ce qui précède n'est pas vrai, comme mentionné dans les commentaires. J'ai raté le fait que les futurs sont créés en dehors de la pour-compréhension.

Et deuxièmement, comme vous l'avez remarqué, si l'un des futurs échoue, l'autre est perdu.

Pour contourner le fait que si l'un des contrats à terme échoue, le résultat de l'autre est perdu, vous pouvez "élever" vos futures valeurs à Essayer :

 (f1.liftToTry zip f2.liftToTry).map { 
    case (Success(foo), Success(bar)) => ... 
    ...
 }

Maintenant, vous pouvez faire quelque chose comme:

 object FutureSyntax { 
   implicit class FutureOps[A](val fu: Future[A]) extends AnyVal {
      def liftToTry: Future[Try[A]] = fu.transform(Success(_))
   }
 }

Si vous vous retrouvez à faire cela souvent, vous pourriez trouver cela utile, "souteneur "vos futurs avec l'opération lift :

 (lifted1 zip lifted2).map { 
   case (Success(foo), Success(bar)) => // both succeeded!
   case (Success(foo), Failure(t)) => // foo succeeded, bar failed with t
   case (Failure(t), Success(bar)) => // guess what!
   case (Failure(t1), Failure(t2)) => // oops
 }

Donc, maintenant, si vous importez FutureSyntax._ , ce qui précède peut être écrit comme

val lifted1: Future[Try[Foo]] = f1.transform(Success(_))
val lifted2: Future[Try[Bar]] = f1.transform(Success(_))

Vous pourriez aussi écrire la même chose avec un pour-compréhension, ce serait juste plus verbeux. La pour-compréhension ne serait pas mon choix dans ce cas: ils sont bons lors du traitement d'une séquence de futurs, où ceux plus tard dans la séquence dépendent des résultats des précédents. Pour traiter des contrats à terme indépendants, zip ou sequence est généralement un meilleur choix.