100tips 总结

柯里化

柯里化就是把接受多个参数的方法变换成接受第一个参数的方法，并且返回接受余下的参数并且返回结果的新方法。

func addTwoNumber(a: Int)(num: Int) -> Int {
    return a + num
}
let addToFour = addTwoNumber(4)
let result = addToFour(6)         // result is 10

Sequence

Swift 的 for...in 可以用在所有实现了 SequenceType 的类型上，而为了实现 SequenceType 你首先需要实现一个 GeneratorType。比如一个实现了反向的 generator 和 sequence 可以这么写：

// 先定义一个实现了 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 i in ReverseSequence(array: arr) {
    print("Index \(i) is \(arr[i])")
}

??

var level : Int?
var startLevel = 1

var currentLevel = level ?? startLevel   // currentLevel = startLevel

??声明为：

func ??<T>(optional: T?, @autoclosure defaultValue: () -> T?) -> T?

func ??<T>(optional: T?, @autoclosure defaultValue: () -> T) -> T

猜测第二种的实现为：

func ??<T>(optional: T?, @autoclosure defaultValue: () -> T) -> T {
    switch optional {
        case .Some(let value):
            return value
        case .None:
            return defaultValue()
        }
}

定义一个操作符

infix operator +* {
    associativity none
    precedence 160
}

infix：中位操作符，前后都是输入，其他还包括prefix, postfix。
associativity：定义了结合律，加法和减法都是left(从左往右)，这里none表示结果不会再和其他结合。
precedence：优先级，乘除是150，加减是140，这里160最高。