swift - SequenceOf 和 LazySequence - 有什么区别和预期用途？

Question

我很难理解为什么 Swift 中有两种几乎相同的不同结构。

• SequenceOf 不懒惰吗？
• 每种的预期用途是什么？

编辑:我想我还是不明白序列中的“惰性”是什么意思……F.e.拿这段使用 SequenceOf 的代码来说应该不是惰性的:

    func myMap<S: SequenceType, V>(source: S, 
      selector: S.Generator.Element -> V) -> SequenceOf<V>  {
      let seq = SequenceOf {
         _ -> GeneratorOf<V> in
         var gen = source.generate()
         return GeneratorOf {
           let v = gen.next()
           println(v)
           return v == nil ? nil : selector(v!)
         }
      }
      return seq
    }

我们用

来调用它

    let a = myMap([1, 2, 3], { $0 * 2 })
    var gen = a.generate()
    let v1 = gen.next()
    let v2 = gen.next()

它打印

可选(1)

可选(2)

在我看来很懒惰......

编辑#2:

当在惰性序列上使用 map 时，它似乎无论如何都在急切地评估元素:

struct TransientView<S: SequenceType> : SequenceType {

    private let seq: S

    init(_ seq: S) {
        self.seq = seq
    }

    func generate()
        -> GeneratorOf<S.Generator.Element> {
            var g = seq.generate()
            return GeneratorOf {
                println("next")
                return g.next()
            }
    }
}

let seq = lazy(map(TransientView([1, 2, 3]), { $0 * 2 })) 

打印“next”4 次...

编辑#3。这是我目前的看法:说“SequenceOf 不懒惰”是错误的。而是“SequenceOf 是用非惰性 .map、.filter 等扩展的”。完全可以编写适用于任何序列(包括 SequenceOf)的 map、filer 等惰性版本。但是，Apple 决定不仅将“懒惰”范例应用于序列实例，而且还将其应用于序列元素 - 因此，如果您将序列变量声明为惰性，则使用 LazySequence 并且这样的扩展是惰性的。我认为这是错误的方法，惰性声明不应该转移到元素——相反，元素应该尽可能保持惰性。将懒惰转换为渴望很容易，但否则就不可能了。

Answer 1

Is SequenceOf not lazy?

正确。这不是懒惰。这就是惰性形式存在的原因。

What are the intended uses for each?

Airpseed Velocity可能对各种类型进行了最全面的讨论。 SequenceOf 提供了从闭包生成序列的简单方法。它还提供了一种“序列类型转换”，可将一种序列类型转换为另一种序列类型。

LazySequence 主要是使用 lazy 函数创建的。空速速度的 Working at being lazy给出了一个很好的介绍。它的目的是避免在实际需要之前生成元素，这对于无限序列特别有用，但在您可能不需要所有元素的任何情况下都很有用，而且生成它们并非易事。

我有没有提到你应该阅读 Airspeed Velocity如果您想深入研究这些东西？但仍然值得记住的是，我们只能从标题中推断出我们可以从 devforum 讨论中收集到的信息，以及从我们对 Swift 的其他了解中获得的直觉。较低级别的类型还没有很好的记录，并且不是任何“官方”文档的一部分，并且它们在测试版中已经更改了几次。因此，要准确了解 Swift 团队在未来版本中的意图并不总是那么容易。这是迄今为止我们所知道的最好的。

---

编辑:正如我在评论中指出的那样，在 6.1b3 中没有接受并返回 LazySequence 的 map 函数。 LazySequence 上只有一个map 方法。但如果我们愿意，我们可以 build 一个，也许他们最终会添加它:

func map<S: SequenceType, U>(source: LazySequence<S>, transform: S.Generator.Element -> U) -> LazySequence<MapSequenceView<S, U>> {
  return source.map(transform)
}