在Scala Akka future中，map和flatMap有什么区别？

Question

在普通的 Scala 中，map 和 flatMap 的不同之处在于，flatMap 将返回一个扁平化到列表中的数据的可迭代对象。 然而在Akka文档中，map和flatMap似乎做了一些不同的事情？

http://akka.io/docs/akka/1.1/scala/futures.html

它说“通常这工作得很好，因为这意味着运行快速函数的开销非常小。如果函数有可能花费大量时间来处理，那么最好有这同时进行，为此，我们使用 flatMap：“

val f1 = Future {
  "Hello" + "World"
}

val f2 = f1 flatMap {x =>
  Future(x.length)
}

val result = f2.get()

有人可以解释一下 Akka future 中的 map 和 flatMap 之间有什么区别吗？

Answer 1

在“正常”Scala 中（如您所说），map 和 flatMap 与列表无关（例如检查 Option）。

阿列克谢给了你正确的答案。现在，如果你想知道为什么我们需要两者，它允许在编写 future 时使用漂亮的 for 语法。给定类似的内容：

val future3 = for( x <- future1;
                   y <- future2 ) yield ( x + y )

编译器将其重写为：

val future3 = future1.flatMap( x => future2.map( y => x+y ) )

如果遵循方法签名，您应该看到表达式将返回 Future[A] 类型的内容。

假设现在仅使用映射，编译器可以执行以下操作：

val future3 = future1.map( x => future2.map( y => x+y ) )

然而，结果应该是 Future[Future[A]] 类型。这就是为什么你需要将其压平。

要了解背后的概念，这是我读过的最好的介绍之一：

http://www.codecommit.com/blog/ruby/monads-are-not-metaphors

Answer 2

有人可以解释一下 Akka future 中的 map 和 flatMap 之间有什么区别吗？

类型基本上是：

flatMap[A](f: T => Future[A]): Future[A] 

map[A](f: T => A): Future[A] 

Answer 3

我在这里粘贴这两种方法的实现。
英文术语的差异如下
并返回函数的结果作为新的 future

         /** Creates a new future by applying a function to the successful result of
       *  this future. If this future is completed with an exception then the new
       *  future will also contain this exception.
       *
       *  $forComprehensionExamples
       */
      def map[S](f: T => S)(implicit executor: ExecutionContext): Future[S] = { // transform(f, identity)
        val p = Promise[S]()
        onComplete { v => p complete (v map f) }
        p.future
      }

      /** Creates a new future by applying a function to the successful result of
       *  this future, and returns the result of the function as the new future.
       *  If this future is completed with an exception then the new future will
       *  also contain this exception.
       *
       *  $forComprehensionExamples
       */
      def flatMap[S](f: T => Future[S])(implicit executor: ExecutionContext): Future[S] = {
        import impl.Promise.DefaultPromise
        val p = new DefaultPromise[S]()
        onComplete {
          case f: Failure[_] => p complete f.asInstanceOf[Failure[S]]
          case Success(v) => try f(v) match {
            // If possible, link DefaultPromises to avoid space leaks
            case dp: DefaultPromise[_] => dp.asInstanceOf[DefaultPromise[S]].linkRootOf(p)
            case fut => fut.onComplete(p.complete)(internalExecutor)
          } catch { case NonFatal(t) => p failure t }
        }
    p.future
   }

与实现的区别在于，当 Promise 完成时，flatMap 实际上会调用带有结果的函数。

case Success(v) => try f(v) match 

对于一篇精彩的文章，请阅读：http//danielwestheide.com/blog/2013/01/16/the-neophytes-guide-to-scala-part-9-promises-and-futures-in-practice.html