Scala 2.13 视图与 LazyList

Question

我正在将一个项目从 Scala 2.12.1 迁移到 2.13.6，发现 SeqView#flatMap 现在返回一个 View，它没有 distinct 方法。因此，我有一段代码不再编译：

val nodes = debts.view
      .flatMap { case Debt(from, to, _) => List(from, to) }
      .distinct
      .map(name => (name, new Node(name)))
      .toMap

有一种愚蠢的方法可以解决这个问题，将视图转换为 seq，然后再转换回视图：

val nodes = debts.view
      .flatMap { case Debt(from, to, _) => List(from, to) }.toSeq.view
      .distinct
      .map(name => (name, new Node(name)))
      .toMap

但是，这显然不是很好，因为它会强制收集视图，而且必须在类型之间来回切换也非常不雅。我找到了另一种解决方法，即使用LazyList：

val nodes = debts.to(LazyList)
      .flatMap { case Debt(from, to, _) => List(from, to) }
      .distinct
      .map(name => (name, new Node(name)))
      .toMap

现在这就是我想要的，它基本上表现得像一个 Java 流。当然，有些操作有 O(n) 的内存使用量，例如 distinct，但至少所有操作在流式传输之后，无需重构数据结构。

有了这个，我开始思考为什么我们应该需要一个视图，因为它们的功能远没有以前那么强大（即使我相信 2.13 已经修复了这个功能引入的一些其他问题）。我寻找答案并找到了提示，但没有发现足够全面的内容。以下是我的研究：

• Description of views in 2.13
• 堆栈溢出：What is the difference between List.view and LazyList?
• Another comparison on an external website

可能是我，但即使在阅读了这些参考资料后，我也没有发现使用视图有明显的好处，即使不是全部用例也是如此。还有比我更开明的人吗？

Answer 1

Scala 2.13 中的惰性序列实际上有 3 种基本可能性：View、Iterator 和 LazyList。

View 是最简单的惰性序列，附加成本极低。在一般情况下默认使用它是很好的，以避免在处理大型序列时分配中间结果。

可以多次遍历视图（使用 foreach、foldLeft、toMap 等）。每次遍历都会单独执行转换（map、flatMap、filter 等）。因此，必须注意避免耗时的转换，或者只遍历视图一次。

迭代器只能被遍历一次。它类似于 Java Streams 或 Python 生成器。 Iterator 上的大多数转换方法要求您只使用返回的 Iterator 并丢弃原始对象。

它也像 View 一样快速并支持更多操作，包括 distinct。

LazyList 基本上是一个真正的严格结构，可以动态自动扩展。 LazyList 记忆所有生成的元素。如果您有一个带有 LazyList 的 val，则将为所有生成的元素分配内存。但是如果你在运行中遍历它并且不存储在val 中，垃圾收集器可以清理遍历的元素。

Scala 2.12 中的 Stream 比 Views 或 Iterators 慢得多。我不确定这是否适用于 Scala 2.13 中的 LazyList。

---

所以每个惰性序列都有一些警告：

• 视图可以多次执行转换。
• 迭代器只能使用一次。
• LazyList 可以为所有序列元素分配内存。

我认为在您的用例中，最合适的是 Iterator：

val nodes = debts.iterator
      .flatMap { case Debt(from, to, _) => List(from, to) }
      .distinct
      .map(name => (name, new Node(name)))
      .toMap