Swift之Generator/Sequence/Collection

 

Generator

Swift中，Generator是任何实现了GeneratorType协议的类或者结构体。Generator可以理解为一个序列生成器。GeneratorType协议要求定义一个名为Element的别名，并实现一个next方法。

GeneratorType协议实现如下：

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

语句typealias Element要求实现这个协议的类必须定义一个名为Element的别名，这样一定程度上实现了泛型协议。协议同时要求实现next函数，其返回值是别名中定义的Element类型，next函数代表生成器要生成的下一个元素。

下面代码实现了一个菲波那契数列生成器：

classFibonacciGenerator: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 =10var generator =FibonacciGenerator()while n-->0{
    println(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的函数的类。

下面代码使用上文中提到的菲波那契数列生成器，实现了一个菲波那契数列：

classFibonacciSequence:SequenceType{
    typealias GeneratorType=FibonacciGenerator
    func generate()->FibonacciGenerator{returnFibonacciGenerator()}}

下面代码打印了10个菲波那契数列，以显示如何使用该序列：

let fib =FibonacciSequence().generate()for _ in1..<10{
    println(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:ForwardIndexTypevar 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 accesslet 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
}

 

 

thx：http://ju.outofmemory.cn/entry/127998

 

 

 

 

 

 

评论

3 楼 啸笑天 2015-12-15  

http://www.jianshu.com/p/caeddaec5e35
SequenceType 与 GeneratorType

2 楼 啸笑天 2015-12-15  

http://nshipster.cn/swift-comparison-protocols/  
Swift Comparison Protocols

1 楼 啸笑天 2015-12-15  

http://www.futantan.com/2015/09/06/Sequence-Conformance/?utm_source=tuicool&utm_medium=referral    
Swift中序列的实现方式