Scala 中的惰性列表

Question

假设我们有以下 LazyList 定义：

val fibs: LazyList[BigInt] = BigInt(0) #:: BigInt(1) #::
fibs.zip(fibs.tail).map(pair => pair._1 + pair._2)

我的问题是它是如何执行的，因为这个定义说我们取尾部并为每一对（来自 zip）进行计算。但是，如果我们想计算索引为 10 的元素，我们已经有了 ...8、9 的值。所以问题是......这是以某种方式优化的，还是对于每个下一个元素，我们都会遍历所有对？

Answer 1

添加上-

1. LazyList 本质上是一个 LinkedList，这意味着要访问第 10 个元素，您必须先遍历所有元素。

2. #:: 操作符/方法本质上最终创建了一个新类，这是库代码-

   implicit def toDeferrer[A](l: => LazyList[A]): Deferrer[A] = new Deferrer[A](() => l)
   
   final class Deferrer[A] private[LazyList] (private val l: () => LazyList[A]) extends AnyVal {
   
     /** Construct a LazyList consisting of a given first element followed by elements
       *  from another LazyList.
       */
     def #::[B >: A](elem: => B): LazyList[B] = newLL(sCons(elem, l()))
   
     /** Construct a LazyList consisting of the concatenation of the given LazyList and
       *  another LazyList.
       */
     def #:::[B >: A](prefix: LazyList[B]): LazyList[B] = prefix lazyAppendedAll l()
   }
   

然后对象创建的顺序是-

1. 懒洋洋地包裹在 Function0 fibs.zip(fibs.tail).map(pair => pair._1 + pair._2)
2. 之后我们有 cons 运算符#:: 可用，我们附加一个新的头部BigInt(1)
3. 最后，我们再次将一个新头附加到 LinkedList BigInt(0)，现在我们的递归结构已准备就绪。
4. 再一次，一切仍然是惰性构建的，这就是为什么我们最终不会取消对 null 的引用

当我们调用 head 时，我们开始展开，然后懒惰开始采取行动。

此外，LazyList 内部使用此 State 结构来建模头部和尾部

private sealed trait State[+A] extends Serializable {
  def head: A
  def tail: LazyList[A]
}

这个结构是它在第一次访问每个元素时记忆的内容。

private lazy val state: State[A] = { ... }