Scala 如何实现自定义的简单“未来”？

我正在尝试实现一个简单的自定义

Future

，它类似于

scala.concurrent.Future

，但要简单得多

我定义了一个特征，比如：

trait MyFuture[+T] {
  def map[K](f: T => K): MyFuture[K]
  def flatMap[K](f: T => MyFuture[K]): MyFuture[K]
  def recover[K](f: Throwable => K): MyFuture[K]
  def recoverWith[K](f: Throwable => MyFuture[K]): MyFuture[K]
}

object MyFuture {
  def apply[T](body: => T): MyFuture[T] = ???
}

object MyAwait {
  def result[T](myFuture: MyFuture[T], atMost: Int /*mills*/): T = ???
}

我可以基于这些API做这样的事情：

val future = MyFuture(3).map(_+1).flatMap(x=>MyFuture(x*x))
val result = MyAwait.result(future,100)
// result: 16

---

不幸的是，我找不到实现它的方法。我已经研究了

scala.concurrent.Future

，但这对于学习来说太复杂了

，我将从提交到

apply

中隐式添加的线程池开始。此任务应运行

body

，然后呼叫订阅者

map

，

flatMap

等应该添加订阅者，如果他们没有被调用，并且您的可调用任务已经完成，就给他们打电话。而且，顺便说一句，这一切都应该是线程安全的，所以您需要并发集合和订阅服务器列表的CA。这就是实际scala的

未来

的工作原理……更不用说，因为它实际上在

映射

/

平面映射

实现中使用了承诺（可订阅事件）的概念。有一个基本的ADT实现，使用的不是线程池，而是continuations。@您所说的phg实现也基于“Free”monad和线程池（用于执行）<这里的code>Asyncword可能会让人困惑，但实际上它只是一个case类，实现了

Future

@phg

Async

接受一个处理程序，这个处理程序接受

a=>Trampoline[a]

，而这个处理程序实际上是链中的下一个处理程序。默认实现在另一个线程中执行计算（使用callable-请参阅我的第一条注释），使用result获得一个trampoline（免费monad）并调用它继续。为什么不简单地使用

def peer:scala.concurrent.Future[a]

？我将从提交到

apply

中隐式添加的线程池开始。此任务应运行

body

，然后呼叫订阅者

map

，

flatMap

等应该添加订阅者，如果他们没有被调用，并且您的可调用任务已经完成，就给他们打电话。而且，顺便说一句，这一切都应该是线程安全的，所以您需要并发集合和订阅服务器列表的CA。这就是实际scala的

未来

的工作原理……更不用说，因为它实际上在

映射

/

平面映射

实现中使用了承诺（可订阅事件）的概念。有一个基本的ADT实现，使用的不是线程池，而是continuations。@您所说的phg实现也基于“Free”monad和线程池（用于执行）<这里的code>Asyncword可能会让人困惑，但实际上它只是一个case类，实现了

Future

@phg

Async

接受一个处理程序，这个处理程序接受

a=>Trampoline[a]

，而这个处理程序实际上是链中的下一个处理程序。默认实现在另一个线程中执行计算（使用callable-请参阅我的第一条注释），使用result获得一个trampoline（免费monad）并调用它继续。为什么不简单地使用

def peer:scala.concurrent.Future[a]

？