Swift中，Generator是任何实现了GeneratorType协议的类或者结构体。Generator可以理解为一个序列生成器。GeneratorType协议要求定义一个名为Element
的别名，并实现一个next
方法。
GeneratorType协议实现如下：
protocol GeneratorType{
typealias Element
mutating func next()->Element?
}
语句typealias Element要求实现这个协议的类必须定义一个名为Element的别名，这样一定程度上实现了泛型协议。协议同时要求实现next函数，其返回值是别名中定义的Element类型，next函数代表生成器要生成的下一个元素。下面代码实现了一个菲波那契数列生成器：
class FibonacciGenerator:GeneratorType{
var current = 0, nextValue = 1
typealias Element = Int
func next() -> Element?{
let ret = current
current = nextValue
nextValue = nextValue + ret
return ret
}
}
下面代码打印出10个菲波那契数列，以显示如何使用生成器：
var n = 10
var generator = FibonacciGenerator()
while n-- >0 {
print(generator.next()!)
}
Generator是Sequence和Collection的基础。
Sequence
Sequence是任何实现了SequenceType协议的类或者结构体。Sequence可以理解为一个序列。SequenceType协议要求定义一个名为Generator，类型为GeneratorType的别名，并要求实现一个返回生成器Generator的函数。
SequenceType协议如下：
protocol SequenceType:_Sequence_Type{
typealias Generator:GeneratorType
func generate()->Generator
}
类似于GeneratorType协议，typealias Generator : GeneratorType
要求实现这个协议的类必须定义一个名为Generator类型GeneratorType的别名。协议同时要求实现一个名为generate的函数，其返回值为别名Generator定义的类型，这个类型应该实现了上文提到的GeneratorType协议。也就是说Sequence其实是包含一个生成Generator的函数的类。
下面代码使用上文中提到的菲波那契数列生成器，实现了一个菲波那契数列：
class FibonacciSequence:SequenceType{
typealias GeneratorType = FibonacciGenerator
func generate() -> FibonacciGenerator{
return FibonacciGenerator()
}
}
下面代码打印了10个菲波那契数列，以显示如何使用该序列：
let fib = FibonacciSequence().generate()
for _ in 1..<10 {
print(fib.next()!)
}
符合SequenceType的序列有可能成为惰性序列。成为惰性序列的方法是对其显示的调用lazy函数：
let r = lazy(stride(from:1, to:8, by:2))
函数stride返回一个结构体StrideTo，这个结构体是Sequence。所以，lazy函数返回一个lazySequence对象。
Collection
Collection是实现了CollectionType协议的协议的类或者结构体。CollectionType协议继承了SequenceType协议。所以，Collection也都实现了SequenceType，它同时也是Sequence。
CollectionType协议如下：
protocol _CollectionType:_SequenceType{
typealias Index:ForwardIndexType
var startIndex:Index{get}
var endIndex:Index{get}
typealias _Element
subscript (_i:Index)->_Element{get}
}
protocol CollectionType:_CollectionType,SequenceType{
subscript (position:Self.Index)->Self.Generator.Element{get}
}
所以，CollectionType协议首先实现了SequenceType协议，并要求实现一个subscript方法以获取序列中每个位置的元素值。
Swift中，大量内置类如Dictionary，Array，Range，String都实现了CollectionType协议。所以，Swift大部分容器类都可以变为惰性序列。
// a will be a LazyRandomAccessCollection
// since arrays are random access
let a = lazy([1,2,3,4])
// s will be a LazyBidirectionalCollectionlet
s = lazy("hello")
总结
Swift里的集合数据结构默认是严格求值的。但是，Swift也提供了惰性语法，在需要惰性时，你需要显式声明。这为开发者在Swift中使用惰性提供了条件。
demo：
import Foundation
// 先定义一个实现了 GeneratorType protocol 的类型
// GeneratorType 需要指定一个 typealias Element
// 以及提供一个返回 Element? 的方法 next()
class ReverseGenerator: GeneratorType {
typealias Element = Int
var counter: Element
init<T>(array: [T]) {
self.counter = array.count - 1
}
init(start: Int) {
self.counter = start
}
func next() -> Element? {
return self.counter < 0 ? nil : counter--
}
}
// 然后我们来定义 SequenceType
// 和 GeneratorType 很类似，不过换成指定一个 typealias Generator
// 以及提供一个返回 Generator? 的方法 generate()
struct ReverseSequence<T>: SequenceType {
var array: [T]
init (array: [T]) {
self.array = array
}
typealias Generator = ReverseGenerator
func generate() -> Generator {
return ReverseGenerator(array: array)
}
}
let arr = [0,1,2,3,4]
/* 对 SequenceType 可以使用 for...in 来循环访问.。
for...in其实做了：
var g = array.generate()
while let obj = g.next() {
print(obj)
}
*/
for i in ReverseSequence(array: arr) {
print("Index \(i) is \(arr[i])")
}
/*
像map , filter reduce这些方法也可以使用
因为SequenceType接口扩展(protocol extension)已经实现了他们：
extension SequenceType {
func map<T>(@noescape transform: (Self.Generator.Element) -> T) -> [T]
func filter(@noescape includeElement: (Self.Generator.Element) -> Bool)
-> [Self.Generator.Element]
@noescape combine: (T, Self.Generator.Element) -> T) -> T
*/
let aaa = ReverseSequence(array: arr)
aaa.map { (Int) -> Int in
return 1
}
