Swift SequenceOf和LazySequence的区别和预期用途是什么？

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

• 这不是懒惰吗
• 它们的预期用途是什么

编辑：我想我还是不明白序列中的“懒惰”是什么意思。。。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
    }

它打印

可选（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 })) 

struct TransientView:SequenceType{
私人出租
初始值（q:S）{
self.seq=seq
}
func生成（）
->发电机{
var g=序列生成（）
返回发生器{
println（“下一个”）
返回g.next（）
}
}
}
设seq=lazy（map（TransientView（[1,2,3]），{$0*2}））

打印“下一步”4次

编辑#3。以下是我目前对此的看法：说“SequenceOf不懒惰”是错误的。它相当于“SequenceOf是用非惰性的.map、.filter等扩展的”。完全可以编写适用于任何序列（包括SequenceOf）的map、filer等的延迟版本。但是，苹果公司决定将“惰性”范式不仅应用于序列实例，还应用于序列元素——因此，如果您将序列变量声明为惰性，则将使用LazySequence，这样的扩展也是惰性的。我认为这是错误的方法，不应该将惰性声明转移到元素——相反，元素应该尽可能保持惰性。将懒惰转化为渴望是很容易的，但在其他方面是不可能的

这不是懒惰吗

对。这不是懒惰。这就是懒惰形式存在的原因

它们的预期用途是什么

可能对各种类型进行了最全面的讨论

SequenceOf

提供了从闭包生成序列的简单方法。它还提供了一种“序列类型转换”，用于将一种序列类型转换为另一种序列类型

LazySequence

主要使用

lazy

函数创建。空速提供了一个很好的介绍。它的目的是避免在实际需要元素之前生成元素，这对于无限序列特别有用，但在任何情况下都很有用，因为您可能不需要所有元素，而且它们的生成非常简单

我有没有提到如果你想深潜的话你应该读一读？但仍然值得记住的是，我们只能从标题中推断，从devforum讨论中收集，从我们对Swift的其他了解中获得直觉。较低级别的类型还没有很好的文档记录，也不是任何“官方”文档的一部分，它们在beta中已经更改了好几次。因此，要准确地知道Swift团队在未来的版本中打算为他们做些什么并不总是容易的。这是迄今为止我们所知道的最好的

---

编辑：正如我在评论中所指出的，在6.1b3中没有

map

函数获取并返回

LazySequence

。在

LazySequence

上只有一个

map

方法。但如果我们愿意，我们可以建造一个，也许他们最终会添加它：

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

func映射（源代码：LazySequence，转换：S.Generator.Element->U）->LazySequence{
返回source.map（转换）
}

谢谢，空速现在是我最好的朋友了！你能解释一下你的懒惰吗还是不明白。。。更新了问题。当您将

map

应用于惰性序列时，它将返回一个新的生成器，而不计算所有值。当您将

map

应用于非惰性序列时，它会立即计算所有值并返回一个数组。map似乎也渴望使用惰性序列-请参阅更新。您正在错误地构造和使用

LazySequence

。尝试

let seq=lazy（TransientView（[1,2,3]）。map{$0*2}

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