scala – 具有返回未来功能的遍历列表和流

Scala的未来(new in 2.10和now 2.9.3)是一个应用函数，这意味着如果我们有一个traversable type F，我们可以采用F [A]和函数A =>未来[B]并将它们变成未来[F] [B]。

此操作在标准库中为Future.traverse. Scalaz 7还提供了更常规的遍历，我们可以在此处使用，如果我们从scalaz-contrib library导入Future的应用函数实例。

在流的情况下，这两个遍历方法的行为不同。标准库遍历在返回之前消耗流，而Scalaz的returns the future immediately：

import scala.concurrent._
import ExecutionContext.Implicits.global

// Hangs.
val standardRes = Future.traverse(Stream.from(1))(future(_))

// Returns immediately.
val scalazRes = Stream.from(1).traverse(future(_))

还有另一个区别，因为Leif Warner观察到here.标准库的遍历会立即启动所有异步操作，而Scalaz启动第一个，等待它完成，启动第二个，等待它等等。

流的不同行为

通过编写一个将在流中第一个值睡眠几秒钟的函数来显示此第二个差异是很容易的：

def howLong(i: Int) = if (i == 1) 10000 else 0

import scalaz._,Scalaz._
import scalaz.contrib.std._

def toFuture(i: Int)(implicit ec: ExecutionContext) = future {
  printf("Starting %d!n",i)
  Thread.sleep(howLong(i))
  printf("Done %d!n",i)
  i
}

Now.traverse(Stream(1，2))(toFuture)将打印如下内容：

Starting 1!
Starting 2!
Done 2!
Done 1!

和Scalaz版本(Stream(1，2).traverse(toFuture))：

Starting 1!
Done 1!
Starting 2!
Done 2!

这可能不是我们想要的。

和列表？

奇怪的是，两个遍历在这方面在列表上表现相同 – Scalaz不等待一个未来在开始下一个之前完成。

另一个未来

Scalaz还包括自己的concurrent套餐，自己实施期货。我们可以使用与上述相同的设置：

import scalaz.concurrent.{ Future => FutureZ,_ }

def toFutureZ(i: Int) = FutureZ {
  printf("Starting %d!n",i)
  i
}

然后我们得到Scalaz对列表和流的流的行为：

Starting 1!
Done 1!
Starting 2!
Done 2!

也许不太令人惊讶的是，遍历无限流仍然立即返回。

题

在这一点上，我们真的需要一个表来总结，但一个列表将要做：

>标准库遍历流;返回前消耗;不要等待每一个未来。
>流与Scalaz遍历：立即返回;等待每一个未来完成。
> Scalaz期货与流：立即回报;等待每一个未来完成。

和：

>标准库遍历列表：不要等待。
>列表与Scalaz遍历：不要等待。
>带有列表的Scalaz期货：等待每一个未来完成。

这是否有意义？列表和流上的此操作是否存在“正确”的行为？是否有一些原因，即“最不同步”的行为 – 即在返回之前不消耗收集，并且不要等待每一个未来的完成，然后继续下一步 – 在这里不代表？