柯里化
柯里化就是把接受多个参数的方法变换成接受第一个参数的方法，并且返回接受余下的参数并且返回结果的新方法。
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最高。
