Scala - Chaining Futures试块？

Question

是否有可能将 scala.util.Try 和 scala.concurrent.Future 链接起来？它们都有效地提供了相同的一元接口，但尝试链接它们会导致编译错误。

例如。给定以下两个签名

def someFuture:Future[String] = ???
def processResult(value:String):Try[String] = ???

有可能做以下事情吗？

val result = for( a <- someFuture; b <- processResult( a ) ) yield b;
result.map { /* Success Block */ } recover { /* Failure Block */ }

这显然会导致编译错误，因为Future和Try不能被平面映射在一起。

然而，能够链接它们将是一个很好的功能 - 这有可能吗？还是我需要将它们组合成一个未来[尝试[字符串]]？

(特别是，我感兴趣的是有一个单独的‘recover’块来捕获将来或将来的异常)。

Answer 1

也许这个问题由来已久，但目前您可以:

  implicit def tryToFuture[T](t:Try[T]):Future[T] = Promise.fromTry(t).future

Answer 2

怎么样

val result = for( a <- someFuture) yield for( b <- processResult( a ) ) yield b;

虽然看起来不整齐。

Answer 3

当遇到这样的问题时，您想在a中使用不同的类型进行理解，一种解决方案可以是尝试选择其中一种类型并将另一种类型映射到它。对于您的情况，考虑到期货的独特属性（异步），我会选择Future作为最小公分母，并将try映射到Future。您可以简单地这样做：

val result = for{
  a <- someFuture
  b <- tryToFuture(processResult(a)) 
}  yield b
result.map { /* Success Block */ } recover { /* Failure Block */ }

def tryToFuture[T](t:Try[T]):Future[T] = {
  t match{
    case Success(s) => Future.successful(s)
    case Failure(ex) => Future.failed(ex)
  }
}

现在，如果您发现这是一种非常常见的情况，并且不喜欢不断地添加显式转换，我想您可以将tryToFuture方法定义为隐式的，并在需要的地方导入它，如下所示：

object FutureHelpers{
  implicit def tryToFuture[T](t:Try[T]):Future[T] = {
    t match{
      case Success(s) => Future.successful(s)
      case Failure(ex) => Future.failed(ex)
    }
  }
}

import FutureHelpers._
val result = for{
  a <- someFuture
  b <- processResult(a) 
}  yield b
result.map { /* Success Block */ } recover { /* Failure Block */ }

请记住，调用< code>Future.success和< code>Future.failed会对< code>ExecutionContext范围内的任何内容产生影响，因为它会向它提交另一个任务。

编辑

正如Viktor在评论中指出的那样，如果您只使用Future.fromTry，则将try转换为Future的过程会更加容易。

val result = for{
  a <- someFuture
  b <- Future.fromTry(processResult(a)) 
}  yield b
result.map { /* Success Block */ } recover { /* Failure Block */ }

与使用隐式或滚动自己的转换逻辑相比，这可能是最好的选择。