Question

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

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]

我不明白？

Answer 1

你可以这样做，没有承诺和异步

  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
    }
  }

使用异步块的全部意义在于，从中返回的是您想要的某种类型（可能不是Future），然后将其包装在其中。因此，如果您需要Option[MyType]返回它，它将被包含在Future中，以便为您提供预期的Future[Option[MyType]]。使异步有用的原因是await（）函数将Future[T]更改为T，您可以正常使用，没有映射和其他类似的东西，它有时比嵌套大量的内容更具可读性flatMaps。

如果你只是promise.future将await()包裹在这个await(promise.future)中，你的代码应该可以正常工作，但这个解决方案对我来说非常难看。

Answer 2

类型Option不是Future类型，请注意if-else表达式，

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

Answer 3

＆＃39;如果＆＃39;声明应返回Option [MyType]，如果您使用async {...}或Future [Option [MyType]]，那么您不需要异步

Scala方法返回Future

3 个答案: