Scala未来{zip map}与{flatMap}的区别

我正在读《scala实践》，其中一个练习是并行化合并排序

我想知道为什么可以翻译成平面图和地图的理解比zip和地图需要更多的时间

我的代码：

def mergeSortParallel0[T: Ordering](items: IndexedSeq[T]): Future[IndexedSeq[T]] = {
    if (items.length <= 16) Future.successful(mergeSortSequential(items))
    else {
        val (left, right) = items.splitAt(items.length / 2)
        for (
          l <- mergeSortParallel0(left);
          r <- mergeSortParallel0(right)
        ) yield merge(l, r)
    }
}
  

def mergeSortParallel0[T:Ordering]（项目：IndexedSeq[T]）：Future[IndexedSeq[T]={
如果（items.length
flatMap
或
map
是Scala Future上的顺序操作，它们本身与并行运行无关。它们可以被视为Future完成时执行的简单回调。或者换句话说，在
map（…）
或
flatMap（…）中提供的代码
将仅在前一个将来完成时开始执行

另一方面，
zip
将并行运行期货，并在两个期货都完成时以元组形式返回结果。类似地，您可以使用
zipWith
，它使用一个函数来转换两个期货的结果（结合zip和map操作）：

实现并行性的另一种方法是在外部声明未来以供理解。这是因为Scala中的未来是“急切的”，并且它们在您声明它们时就开始了（分配给
val
）：

def mergeSortParallel0[T:Ordering]（项目：IndexedSeq[T]）：Future[IndexedSeq[T]={
如果（items.length
flatMap
或
map
是Scala Future上的顺序操作，它们本身与并行运行无关。它们可以被视为Future完成时执行的简单回调。或者换句话说，在
map（…）
或
flatMap（…）中提供的代码
将仅在前一个将来完成时开始执行

另一方面，
zip
将并行运行期货，并在两个期货都完成时以元组形式返回结果。类似地，您可以使用
zipWith
，它使用一个函数来转换两个期货的结果（结合zip和map操作）：

实现并行性的另一种方法是在外部声明未来以供理解。这是因为Scala中的未来是“急切的”，并且它们在您声明它们时就开始了（分配给
val
）：

def mergeSortParallel0[T:Ordering]（项目：IndexedSeq[T]）：Future[IndexedSeq[T]={
如果（项目长度）
def mergeSortParallel0[T: Ordering](items: IndexedSeq[T]): Future[IndexedSeq[T]] = {
    if (items.length <= 16) Future.successful(mergeSortSequential(items))
    else {
        val (left, right) = items.splitAt(items.length / 2)
        mergeSortParallel0(left).zip(mergeSortParallel0(right)).map{
            case (sortedLeft, sortedRight) => merge(sortedLeft, sortedRight)
        }
    }
}

      mergeSortParallel0(left).zipWith(mergeSortParallel0(right)){
        case (sortedLeft, sortedRight) => merge(sortedLeft, sortedRight)
      }

  def mergeSortParallel0[T: Ordering](items: IndexedSeq[T]): Future[IndexedSeq[T]] = {
    if (items.length <= 16) Future.successful(mergeSortSequential(items))
    else {
      val (left, right) = items.splitAt(items.length / 2)
      val leftF = mergeSortParallel0(left)
      val rightF = mergeSortParallel0(right)

      for {
        sortedLeft <- leftF
        sortedRight <- rightF
      } yield {
        merge(sortedLeft, sortedRight)
      }
    }
  }