返回未来的Scala方法

我使用的以下方法利用了异步库：

def myMethod(param: Long, isTru: Boolean): Future[Option[MyType]] = async {

  if (isTru) {
    val promise = Promise[Option[MyType]]

    val myFuture = doSomething(param)

    myFuture.onComplete {
      case Success(succ) => {
        promise.success(Some(MyType(param, succ)))
      }
      case Failure(fail) => promise.failure(fail)
    }

    promise.future // fails here
  }
  else {
    None
  }
}

编译失败，错误如下：

[error] found: scala.concurrent.Future[Option[MyType]]
[error] required: Option[MyType]

---

我不明白是什么？

if'语句的两个分支都应该返回Option[MyType]，如果使用async{…}或Future[Option[MyType]]，那么就不需要async

Type

Option

不是Type

Future

，注意

if-else

表达式

if() {...
  promise.future // fails here
}
else {
  None
}

---

您可以这样做，无需承诺和异步

  def myMethod(param: Long, isTru: Boolean): Future[Option[MyType]] = {

    if (isTru) {
      doSomething(param).map(res => Some(MyType(param, res)))
    }
    else {
      Future.successful(None)
    }
  }

承诺实际上很少被使用

或者，如果要使用async，请执行以下操作：

  def myMethod(param: Long, isTru: Boolean): Future[Option[MyType]] = async {

    if (isTru) {
      val myFuture = doSomething(param)
      val myResult = await(myFuture)

      Some(MyType(param, myResult))
    }
    else {
      None
    }
  }

使用async块的全部意义在于，您从它返回的是您想要的某种类型（可能不是未来），然后它被包装在一个类型中。因此，如果您需要

Option[MyType]

返回它，它将被包装在一个Future中，为您提供预期的

Future[Option[MyType]]

。async之所以有用，是因为它的wait（）函数将

Future[T]

更改为

T

，您可以正常使用，而无需进行映射和其他类似操作，它有时比嵌套大量平面图更具可读性

---

或者，如果您只是将

promise.future

包装在

await（）

中，那么您的代码应该可以工作，就像这样

await（promise.future）

但是这个解决方案对我来说非常难看。

问题是我的await调用在yield块中，我不能在该上下文中使用await。我上面展示的示例只是一个简化版本！好吧，那就简单点，也许我们能想出一些办法。等待当然有它的局限性-