第二篇：Sequence

声明： 以下只是学习笔记，仅作为记录。
定义如下：

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