Scala future的理解失败

Question

我有三个连续的未来，并在理解中使用

val comF = for {
  f1 <- future1
  f2 <- future2
  f3 <- future3
} yield {
  // something
}

comF onSuccess { }
comF onFailure { 
  // ----------------      Here is the problem  --------------------------------
  //
  // How do I know which future failed(throw exception), when the callback comes here ?
  // Thanks for the help! Different futures using different exceptions can solve it.
}

现在我有一个像List[Future[T]这样的未来列表，首先我使用这种方法将其转移到Future[List[T]]（为什么这个未来列表到未来列表的转换编译和工作？）。然后我得到未来

val fList: Future[List[T]]
fList on Failure {
  // 
  // How do I know which is Fail now >??
}

Answer 1

这位受人尊敬的@Rit（Brendan McAdams）终于说服我在他的演讲《怀疑论者看斯卡拉兹的“Gateway Drugs”》中用脱节来尝试斯卡拉兹。您的代码将被包装在析取中，如下所示：

val comF = for {
  f1 <- future1 \/> "Future 1 failed"
  f2 <- future2 \/> "Future 2 failed"
  f3 <- future3 \/> "Future 3 failed"
} yield {
  // something
}

相关问题

Answer 2

您使用的是< code>flatMap，因此期货嵌套在一个期货中。

你的代码是

import scala.concurrent.Future

val future1, future2, future3 = Future[Any]()

val comF = for {
  f1 <- future1
  f2 <- future2
  f3 <- future3
} yield {
  // something
}

comF onSuccess { ??? }
comF onFailure { ??? }

当我将脱糖规则应用于您的理解时，我得到

val comF = (future1).flatMap { case f1 => 
  (future2).flatMap { case f2 => 
    (future3).map { case f3 => {
        // something
      }
    }
  }
}

您可以在此处清楚地看到flatMap的使用。原则上，flatMap做了两件事：它将一个函数应用于第一个Future的结果。这必须是一个函数，它将第一个 Future 的结果映射到另一个 Future，即嵌套在第一个 Future 中的未来（这是映射部分）。然后，它“取消”两个期货，并将它们合并为一个单一的未来（平面部分）。在这一点上，这两种期货不再存在（从概念的角度来看;从技术上讲，它们仍然存在）。相反，只有一个“合并”的未来。

对< code>flatMap的两次调用在原来的三次调用的基础上创建了一个新的< code>Future。这就是为什么你不能发现，三个原始的< code >期货中的哪一个引发了异常:不是它们中的任何一个。相反，新创建的< code>Future运行并引发异常。

如果您想知道在引发异常之前运行了计算的哪些步骤，您必须单独跟踪进度，例如通过Exception中的附加参数。或者，您可以删除（平面图）并一个接一个地运行单个Futures。

首先，我们创建一个新的异常类，其中包含真正的异常以及一些信息，异常来自何处

class ExceptionWithOrigin[T](val origin : T, nested : Throwable) extends Exception(nested)

object ExceptionWithOrigin {
  def wrapFuture[T,U](origin : T, f : Future[U]) : Future[U] = {
    f.transform(Predef.identity, new ExceptionWithOrigin[T](origin,_))
  }

  def wrapFuture[U](f : Future[U]) = wrapFuture(f,f)
}

对于Futures我们没有特殊要求。

val future1,future2,future3 = Future[Any]()

然后，我们使用新创建的异常类的伴随对象中的帮助器方法包装给定的 Futures。

import ExceptionWithOrigin._

val comF = for {
  result1 <- wrapFuture(future1)
  result2 <- wrapFuture(future2)
  result3 <- wrapFuture(future3)
} yield {
  // something
}

当您发现一些异常ex时，您现在只需使用ex.origin来找出它来自哪里。当然，起源并不完全正确。原来的 Futures future1、future2 和 future3 并没有真正执行。取而代之的是，由 flatMap 创建的新创建的未来运行。但尽管如此，起源仍然有效。

顺便说一下，您应该将< code>f1 、< code>f2和< code>f3重命名为< code >结果1 、< code >结果2和< code >结果3。它们不代表一个< code>Future，而是每个< code>Future的计算结果(每个< code>Future返回的值)。

Answer 3

考虑代码：

def func = {
  try {
    val x = maybeThrows
    val y = maybeThrowsToo
    val z = maybeThrowsAsWell
    result(x, y, x)
  } catch (RuntimeException e) {
    // How do I know which maybeThrows failed?
  }
}

未来案例的工作原理基本相同。

即使在＜code＞列表＜/code＞中分组计算也没有帮助：

def func = {
  try {
    val x = maybeThrows
    val y = maybeThrowsToo
    val z = maybeThrowsAsWell
    val list = List(x, y, z)
    result(list)
  } catch (RuntimeException e) {
    // How do I know which maybeThrows failed?
  }
}

扰流器：你必须明确追踪哪一次计算失败。如果使用try/catch完成，将产生一些样板文件。但幸运的是，有了未来（以及尝试），样板文件并没有那么糟糕：

class TaggedException(val idx, exc: Exception)

def tagFailedWithIndex[T](idx: Int, f: Future[T]): Future[T] = 
  future recoverWith { case exc => Future.failed(new TaggedException(idx, exc)) }

val comF = for {
  f1 <- tagFailedWithIndex(0, future1)
  f2 <- tagFailedWithIndex(1, future2)
  f3 <- tagFailedWithIndex(2, future3)
} yield something(f1, f2, f3)

comF onFailure { 
  case exc: TaggedException => "%d computation failed".format(exc.idx)
}

剧透你必须跟踪哪些计算明确失败。如果使用try/catch完成，它将导致很多样板。但幸运的是，有Try，Future的行为更加相同：

class TaggedException(val idx, exc: Exception)

def tagFailedWithIndex[T](idx: Int, f: Future[T]): Future[T] = 
  future recoverWith { case exc => Future.failed(new TaggedException(idx, exc)) }

val comF = for {
  f1 <- tagFailedWithIndex(0, future1)
  f2 <- tagFailedWithIndex(1, future2)
  f3 <- tagFailedWithIndex(2, future3)
} yield something(f1, f2, f3)

comF onFailure { 
  case exc: TaggedException => "%d computation failed".format(exc.idx)
}