Scala 2.13 视图与 LazyList

我正在将一个项目从 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 已经解决了这个功能引入的一些其他问题）。我寻找答案并找到提示，但我发现没有足够全面的内容。以下是我的研究：

• 2.13中视图的说明 https://docs.scala-lang.org/overviews/collections-2.13/views.html
• 堆栈溢出：List.view 和 LazyList 有什么区别？ https://stackoverflow.com/questions/59587449/what-is-the-difference-between-list-view-and-lazylist
• 另一个外部网站的比较 http://www.baeldung.com/scala/stream-vs-views-vs-iterators

可能是我，但即使在阅读了这些参考资料之后，对于大多数（如果不是全部）用例，我也没有发现使用视图的明显优势。还有比我更开明的人吗？

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

View是最简单的惰性序列，几乎没有额外的成本。一般情况下最好使用默认值，以避免在处理大型序列时分配中间结果。

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

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

它也像视图一样快，并且支持更多操作，包括不同的操作。

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

Scala 2.12 中的流比视图或迭代器慢得多。我不确定这是否适用于 Scala 2.13 中的 LazyList。

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

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

我相信在您的用例中，迭代器是最合适的：

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