Scala 何时强制使用流值？

Question

我对流很满意，但我承认我对这种行为感到困惑：

import collection.immutable.Stream
object StreamForceTest extends App {
  println("Computing fibs")
  val fibs: Stream[BigInt] = BigInt(0) #:: BigInt(1) #::
     fibs.zip(fibs.tail).map((x: (BigInt, BigInt)) => {
       println("Adding " + x._1 + " and " + x._2);
       x._1 + x._2
     })
  println("Taking first 5 elements")
  val fibs5 = fibs.take(5)
  println("Computing length of that prefix")
  println("fibs5.length = " + fibs5.length)
}

有输出

Computing fibs
Taking first 5 elements
Computing length of that prefix
Adding 0 and 1
Adding 1 and 1
Adding 1 and 2
fibs5.length = 5

为什么take(5)不应该强制计算流的值， 而length 会这样做吗？随便谁都不需要 看看这些值，但我会认为take 更多 可能比length 做到这一点。检查github上的源代码， 我们找到了take 的这些定义（包括一个有启发性的 评论）：

override def take(n: Int): Stream[A] = (
  // Note that the n == 1 condition appears redundant but is not.
  // It prevents "tail" from being referenced (and its head being evaluated)
  // when obtaining the last element of the result. Such are the challenges
  // of working with a lazy-but-not-really sequence.
  if (n <= 0 || isEmpty) Stream.empty
  else if (n == 1) cons(head, Stream.empty)
  else cons(head, tail take n-1)
)

和length:

override def length: Int = {
  var len = 0
  var left = this
  while (!left.isEmpty) {
    len += 1
    left = left.tail
  }
  len
}

head和tail的定义是从具体的 子类（Empty 和 Cons）。 （当然Empty 是一个对象，而不是一个 类，它的 head 和 tail 的定义只是 throw 例外。）有一些微妙之处，但它们似乎与制作有关 确保 Cons 的 tail 被延迟评估； head 定义直接来自关于 Scala 构造函数的第 0 课。 请注意，length 不会靠近 head，但它是 做强迫症。

所有这些都是关于 Scala 流有多接近的普遍困惑的一部分 是 Haskell 列表。我以为 Haskell 对待头部和尾部 对称（我不是一个认真的 Haskell 黑客），Scala 强制 在更多情况下进行头部评估。我想弄清楚 这些情况究竟是什么。

Answer 1

Stream 的头部是严格的，尾部是惰性的，正如您在 cons.apply 和 Cons constructor 中看到的那样：

def apply[A](hd: A, tl: => Stream[A]) = new Cons(hd, tl)

class Cons[+A](hd: A, tl: => Stream[A]) extends Stream[A]

注意take 方法引用tail 的上下文：

cons(head, tail take n-1)

因为表达式tail take n-1 用作cons 的第二个参数，它传递给by name，它不会强制评估tail take n-1，因此不会强制评估tail。

而在length 中，声明

left = left.tail

，通过将left.tail 分配给var，确实会强制对其进行评估。

Scala 是“默认严格的”。在大多数 情况下，您引用的所有内容都会被评估。我们仅在方法/构造函数参数使用 => 声明按名称调用参数的情况下进行惰性评估，并且在文化中我们通常不使用它，除非有特殊原因。

Answer 2

让我提供另一个答案，只是从高层次上看，即没有实际考虑代码。

如果您想知道 Stream 有多长，您必须从头到尾评估它。否则，你只能猜测它的长度。诚然，您可能并不真正关心这些值（因为您只想计算它们），但这并不重要。

另一方面，当您从流（或任何集合）中“获取”一定数量的元素时，您只是在说您最多想要该数量的元素。结果仍然是一个流，即使它可能已被截断。