声明： 以下只是学习笔记，仅作为记录。
定义如下：
protocol Sequence {
associatedtype Iterator : IteratorProtocol
public func makeIterator() -> Self.Iterator
简单使用
struct DishesIterator:IteratorProtocol {
var dishes:[String]
typealias Element = String
init(dishes:[String]) {
self.dishes = dishes
}
mutating func next() -> String? {
return dishes.removeFirst()
}
}
struct DishesSequence:Sequence {
var dishes:[String]
init(dishes:[String]) {
self.dishes = dishes
}
func makeIterator() -> DishesIterator {
return DishesIterator(dishes: self.dishes)
}
}
let dishesSequence = DishesSequence(dishes: ["🐟","🦐"])
var dishesIterator = dishesSequence.makeIterator()
dishesIterator.next()
dishesIterator.next()
对比之前用法，我们每次都会实例化一个迭代器，传入内容，然后多次调用next 方法来获取元素，直到取尽nil。如果此时还想要重新遍历，我们不得不重新实例化一个新的迭代器。
那么现在是我们传入内容实例化一个序列，然后调用 makeIterator 生成一个迭代器给我们，后面的事情就和前面一样了；如果我们还想要重新遍历，只需对序列调用 makeIterator 生成一个新的迭代器来用即可。
两者本质都是生成新的迭代器达到重新遍历的目的，后者为什么要这么实现呢？有什么好处呢？———— 这些都是此时我疑惑的地方。
Functional Swift 一书中这么解释：
通过在 Sequence 的定义中封装生成器的创 建过程，开发者在使用序列时不必再担心潜在的生成器创建问题。这与面向对象理念中的将使 用和创建进行分离的思想是一脉相承的，代码亦由此具有了更高的内聚性。
我们存菜名的数据结构可以是数组，哈希表，二叉树，链表等等，这里和数据创建相关；而针对不同的数据结构，我们需要创建不同的迭代器来适配，这些是数据的使用。而且在 Sequence 中我们没有将迭代器代码写在里面，而是分离了创建和使用，序列其实是不知道迭代器的具体实现的，而只知道它的接口，另外一个好处是内聚性高，意思就是关联性强，试想如果把遍历方式单独写成一个函数，然后传入数据源遍历，显然前者的联系更强。
小结
为了演示Sequence，才有了上面的例子，实际上["🐟","🦐"]就是一个序列，就可以调用makeIterator 方法来生成对应的迭代器拉！
而我们却做了如此多的“无用功”。。。
思考
IteratorOverOne的实现方式。 构建一个只包含单个元素的序列有什么用？
// 构建一个只包含单个元素的序列
func one<A>(x:A)->AnySequence<A>{
return AnySequence(IteratorOverOne(_elements: x))
}
我将定期更新有关此分类的学习笔记。
请关注我的微博：Ninth_Day
