** 這是我的集合系列文章的第一篇，計劃從淺入深通過一系列文章將swift的集合相關內容徹底整理清楚，包括集合類相關的第三方代碼庫，最后自定義一個集合類型，把所有的內容用代碼貫穿起來。**

Generators, Sequences 和 Collections 是swift標準庫的重要組成部分，也是我們編程過程中最常用到的內容，所以理解它們是如何工作的可以很好的提升我們的基本功。如果你能打開playground運行一下本文的代碼，那么會更好的下面的內容。

Generators

我們可以把Generators看做是生成器，它的作用就是提供下一個元素，如果沒有下一個元素則返回nil,標識生產過程結束。從代碼層面看Generator封裝了迭代器的狀態以及迭代器接口。它通過提供一個叫做next()的方法來返回sequence中的下一個元素。

我們可以通過實現 GeneratorType 協議來獲得一個 Generator，

protocol GeneratorType {
 associatedtype Element
  mutating func next() -> Element?
}

要實現這個協議我們要做的事情并不多,我們只需要讓next()方法返回下一個元素，并且在沒有元素的時候返回nil就可以了。

import Foundation

func pow2(power: Int) -> Int {
    return Int(pow(2.0, Double(power)))
}

struct PowersOfTwoGenerator1 : GeneratorType {
    associatedtype Element = Int
    var power : Int = 0
    mutating func next() -> Element? {
        return pow2(power++)
    }
}

現在我們已經成功的獲得了一個 Generator，我們可以調用它了。

var n = 10
var g = PowersOfTwoGenerator1()
while n > 0 {
  n -= 1
  println(g.next()!)
}

我們只需要調用next()方法就可以源源不斷的獲得“下一個元素”了，雖然很簡單，但是有一些遺憾，我們只能通過外部的邏輯才能控制元素的個數(在while循環中控制 n
的個數)，現在我們計劃把這個工作交給 Generator 自己。

struct PowersOfTwoGenerator2 : GeneratorType {
    associatedtype Element = Int
    var power : Int = 0
    let endPower : Int
    init(end : Int) {
        endPower = end
    }
    mutating func next() -> Element? {
        return (power < endPower) ? pow2(power++) : nil
    }
}

我們給 Generator 一個構造器，通過構造器來設置一個停止生產元素的條件。

var g2 = PowersOfTwoGenerator2(end:10)
while let x = g2.next() {
    println(x)
}

只做了一個小改動，是不是讓調用代碼簡潔了很多？

到這里我們可以看到，一個 Generator 能做的工作并不多，一但返回nil，Generator的工作就結束了。

Sequences

sequence首先是一個values的序列，它可以使用for in循環控制結構進行迭代。另一方面sequence是Generator的工廠類，它知道如何生產一個適合的Generator。

我們可以通過實現SequenceType協議來獲得一個sequence，這部分工作也不復雜。

struct PowersOfTwoSequence2 : SequenceType {
    associatedtype Generator = PowersOfTwoGenerator2
    let endPower : Int
    init(end: Int) {
        self.endPower = end
    }
    func generate() -> Generator {
        return Generator(end: self.endPower)
    }
}

太棒了，我們現在已經獲得一個sequence了，快用for in遍歷一下試試。

for x in PowersOfTwoSequence2(end:10) {
    println(x)
}

雖然 PowersOfTwoSequence2 已經可以工作了，但它的實現有一個遺憾，endPower這個屬性需要分別在 PowersOfTwoSequence2 與 PowersOfTwoGenerator2中初始化兩次，我們不能容忍一個屬性如此的放縱.

struct PowersOfTwoSequence4 : SequenceType {
    let endPower : Int
    init(end: Int) {
        self.endPower = end
    }
    func generate() -> AnyGenerator<Int> {
        var power : Int = 0
        let nextClosure : () -> Int? = {
            (power < self.endPower) ? pow2(power++) : nil
        }
        return AnyGenerator<Int>(nextClosure)
    }
}

在這段代碼里，我們讓 generate() 返回一個 AnyGenerator ，AnyGenerator實現了 GeneratorType 協議，并且可以通過閉包的方式來創建 next() 方法。我們創建一個閉包 nextClosure 并溝通構造器傳遞個 AnyGenerator ，從而完成了 Generator 的創建。因為閉包幫助我們綁定了 endPower ，所以我們解決了 之前屬性需要被初始化兩次的問題。

我們可以通過尾閉包的方式，進一步精簡代碼。

struct PowersOfTwoSequence5 : SequenceType {
    let endPower : Int
    init(end: Int) {
        self.endPower = end
    }
    func generate() -> AnyGenerator<Int> {
        var power : Int = 0
        return AnyGenerator<Int> {
            (power < self.endPower) ? pow2(power++) : nil
        }
    }
}

Collections

一個 collection就是一個實現了 startIndex 和 endIndex 并且可以通過下標(subscript)訪問的sequence。collection比sequence更進一步的做到了，允許單個元素可以重復訪問。

集合協議擴展了SequenceType。

public protocol CollectionType : Indexable, SequenceType {
    public var startIndex: Self.Index { get }
    public var endIndex: Self.Index { get }
    public subscript (position: Self.Index) -> Self._Element { get }
}

實現一個集合協議的工作比實現一個SequenceType的工作稍微多一些。

    
struct PowersOfTwoCollection : CollectionType {
    associatedtype Index = Int
    let startIndex : Int
    let endIndex : Int
    init(start:Int, end: Int) {
        self.startIndex = start
        self.endIndex = end
    }
    func generate() -> AnyGenerator<Int> {
        var power : Int = 0
        return AnyGenerator<Int> {
            (power < self.endIndex) ? pow2(power++) : nil
        }
    }
    subscript(i: Index) -> Int { return pow2(i) }
}

我們在 PowersOfTwoSequence5 的基礎很容實現 CollectionType 協議。通過構造函數，為collection初始化 startIndex 與 endIndex。提供subscript來為collection提供下標訪問的能力。現在我們擁有一個集合了。

for x in reverse(PowersOfTwoCollection(start:0,end:10)) {
    println(x)
}

關于集合，這里只是剛剛開始，如果大家希望了解更多的集合內容，歡迎大家關注我后面的更新。我正在深入的研究swift語言，并將我的學習內容不斷的總結出來，希望能和大家交流共同進步。