scala - 为什么我们需要 Future 和 Promise？

Question

据我所知，Future是只读的，并且 Promise是一次写入的数据结构。

我们需要一个 Promise完成一个 Future
例如，

object Lie extends Throwable

val lie = Future { throw Lie } 

val guess = Promise[String]()     

lie.onComplete { case Success(s) => guess.success("I knew it was true!") 
                 case Failure(t) => guess.failure("I knew it was lie")} 
// return type: Unit 

guess.future.map(println) 
// res12: scala.concurrent.Future[Unit] = List()
// I knew it was lie!
// Requires Promise to chain Future with exception 

但是，我不明白为什么我们需要同时拥有 Future和 Promise
我猜 Promise是必需的，因为 Future.onComplete签名

自 Future.onComplete返回类型是 Unit , Future有可能的异常(exception)不能被链接

我假设 Promise被引入以克服此限制

但是为什么不直接更改 Future.onComplete 的签名呢？ ?

更改 Future.onComplete 的返回类型如 Future[T]将在 Future 上启用链接除了

然后， Future不需要 Promise
比如上面的代码可以改成

val lie = Future { throw Lie } 

lie.onComplete { 
   case Success(s) => "I knew it was true!"
   case Failure(t) => "I knew it was lie!"
}.map(println) 

//onComplete return type is Future[String]

我的问题是

1)我是对的吗？是否 Future不需要 Promise , 如果 onComplete 签名从 Unit 改变至 Future[T] ?

2) 为什么 Future 和 Promise 首先被划分？

UDPATE

感谢回复者，现在我明白了 Promise 的目的。它实际上不是为了 Future链接

如果可以，我可以问你吗

为什么 onComplete返回 Unit ??

它实际上可以返回 Future[T]轻松启用链接 Future

例如

Future { throw Error }.onComplete {
  case Success(s) => "Success" 
  case Failure(t) => throw Error
}.onComplete {
  case Success(s) => "Success"
  case Failure(t) => throw Error 
}. ... 

Answer 1

Future.apply[T](block: => T): Future[T]是 Future.unit.map(_ => block) 的语法糖[1]

一个 Future表示当前可能可用也可能不可用的值。

一个 Promise代表在某个时候提供这样一个值的义务。

为 Future 设置单独的实体(用于读取)和 Promise (对于写入)意味着很容易推理功能:

当 Future 是一个参数时，它是一个在某个时刻拥有某个值的请求，当它被用作返回类型时，它是一个当前可能不可用的响应。

当一个 Promise 是一个参数时，它是在某个点产生某个值的责任的“消耗”，当它用作返回类型时，它是在某个点产生值的责任的“生产”。

总而言之，能够推理能力，尤其是在异步甚至并发程序中，是非常有值(value)的。

大多数情况下不需要使用 Promises，因为它由 Future-combinators 透明地处理——但是当与第三方软件或网络库集成时，它可能非常有用。

有关 Scala 2.12 中有趣的新功能的更多信息，请查看 here .

1:哪里 Future.unit定义为: val unit: Future[Unit] = Future.successful(())