柯里化 (Currying)
Swift 可以将方法进行柯里化，即 把接受多个参数的方法进行一些变形，使其更加灵活的方法
例如：
将输入数字加1 函数
func addOne(num: Int) -> Int {
return num + 1
}
所表达的内容非常有限，我们其实可以定义一个通用的函数，它将接受需要与输入数字相加的数，并返回一个函数。
返回的函数将接受输入数字本身，然后进行操作：
func addTo(_ adder: Int) -> (Int) -> Int {
return {
num in
return num + adder
}
}
let addTwo = addTo(2)
let result = addTwo(6)
print("result:\(result)") //result:8
例如：创建一个比较大小的函数：
func greaterThan(_ comparer: Int) -> (Int) -> Bool {
return { $0 > comparer }
}
let greaterThan10 = greaterThan(10)
let flag = greaterThan10(13) // => true
let flag1 = greaterThan10(9) // => false”
print("\(flag), \(flag1)")
柯里化是一种量产相似方法的好办法，可以通过柯里化一个方法模板来避免写出很多重复代码，也方便了今后维护
将 protocol 的方法声明为 mutating
Swift 的 protocol 不仅可以被 class 类型实现，也适用于 struct 和 enum。
Swift 的 mutating 关键字修饰方法是为了能在该方法中修改 struct 或是 enum 的变量
所以如果你没在协议方法里写 mutating 的话，别人如果用 struct 或者 enum 来实现这个协议的话，就不能在方法里改变自己的变量了
多元组 (Tuple)
交换输入，普通程序员亘古以来可能都是这么写的
func swapMe1( a: inout T, b: inout T) {
let temp = a
a = b
b = temp
}
但是要是使用多元组的话，我们可以用文艺程序员的写法：
func swapMe2( a: inout T, b: inout T) {
(a,b) = (b,a)
}
@autoclosure 和 ??
(1) 简单说，@autoclosure 做的事情就是：把一句表达式自动地封装成一个闭包 (closure)
比如我们有一个方法接受一个闭包，当闭包执行的结果为 true 的时候进行打印：
func logIfTrue(_ predicate: () -> Bool) {
if predicate() {
print("True")
}
}
调用 ：
logIfTrue({return 2 > 1}) //可省略return
因为这个闭包是最后一个参数，所以可以使用尾随闭包 (trailing closure) 的方式把大括号拿出来，然后省略括号，变成：
logIfTrue{2 > 1}
但是这样要么书写麻烦，要么表达不够清晰，于是可以使用 @autoclosure 关键字：
func logIfTrue(_ predicate: @autoclosure () -> Bool) {
if predicate() {
print("True")
}
}
调用：
logIfTrue(2 > 1) // Swift 将会把 2 > 1 这个表达式自动转换为 () -> Bool
(2) 在 Swift 中，有一个非常有用的操作符，可以用来快速地对 nil 进行条件判断，那就是 ??。
这个操作符可以判断输入并在当左侧的值是非 nil 的 Optional 值时返回其 value，当左侧是 nil 时返回右侧的值，比如:
var level: Int?
var startLevel = 1
var currentLevel = level ?? startLevel // currentLevel = 1
?? 内部实现有两种版本：
func ??(optional: T?, defaultValue: @autoclosure () -> T?) -> T?
func ??(optional: T?, defaultValue: @autoclosure () -> T) -> T
@escaping
Swift 的语法非常适合函数式编程的使用，而闭包 (closure) 正是函数式编程的核心概念之一
func doWork(block: ()->()) {
block()
}
doWork {
print("work")
}
这种最简单的形式的闭包其实还默认隐藏了一个假设，那就是参数中 block 的内容会在 doWork 返回前就完成。也就是说，对于 block 的调用是同步行为。
如果我们改变一下代码，将 block 放到一个 Dispatch 中去，让它在 doWork 返回后被调用的话，我们就需要在 block 的类型前加上 @escaping 标记来表明这个闭包是会“逃逸”出该方法的：
func doWorkAsync(block: @escaping ()->()) {
DispatchQueue.main.async {
block()
}
}
doWorkAsync {
print("doWorkAsync")
}
调用的不同之处：
对于 doWork 参数里这样的没有逃逸行为的闭包，因为闭包的作用域不会超过函数本身，所以我们不需要担心在闭包内持有 self 等。
而接受 @escaping 的 doWorkAsync 则有所不同。由于需要确保闭包内的成员依然有效，如果在闭包内引用了 self 及其成员的话，Swift 将强制我们明确地写出 self
如果我们不希望在闭包中持有 self，可以使用 [weak self]
Optional Chaining （可选链）
使用 Optional Chaining 可以让我们摆脱很多不必要的判断和取值，但是在使用的时候需要小心陷阱。
因为 Optional Chaining 是随时都可能提前返回 nil 的，所以使用 Optional Chaining 所得到的东西其实都是 Optional 的。
例如：
class Toy {
let name: String
init(name: String) {
self.name = name
}
}
class Pet {
var toy: Toy?
}
class Child {
var pet: Pet?
}
我们想要知道小明的宠物的玩具的名字的时候，可以通过下面的 Optional Chaining 拿到：
let toyName = xiaoming.pet?.toy?.name
注意虽然我们最后访问的是 name，并且在 Toy 的定义中 name 是被定义为一个确定的 String 而非 String? 的，但是我们拿到的 toyName 其实还是一个 String? 的类型。
这是由于在 Optional Chaining 中我们在任意一个 ?. 的时候都可能遇到 nil 而提前返回，这个时候当然就只能拿到 nil 了。
在实际的使用中，我们大多数情况下可能更希望使用 Optional Binding (可选绑定) 来直接取值的这样的代码：
if let toyName = xiaoming.pet?.toy?.name {
// 太好了，小明既有宠物，而且宠物还正好有个玩具
}
操作符
与 Objective-C 不同，Swift 支持重载操作符这样的特性，最常见的使用方式可能就是定义一些简便的计算了。
比如我们需要一个表示二维向量的数据结构：
struct Vector2D {
var x = 0.0
var y = 0.0
}
一个简单需求是两个 Vector2D 相加
普通写法：
let v1 = Vector2D(x: 2.0, y: 3.0)
let v2 = Vector2D(x: 1.0, y: 4.0)
let v3 = Vector2D(x: v1.x + v2.x, y: v1.y + v2.y)
// v3 为 {x 3.0, y 7.0}
重载+操作符高级写法：
func +(left: Vector2D, right: Vector2D) -> Vector2D {
return Vector2D(x: left.x + right.x, y: left.y + right.y)
}
let v4 = v1 + v2
// v4 为 {x 3.0, y 7.0}
如果我们想要定义一个全新的运算符的话，要做的事情会多一件。
比如点积运算就是一个在矢量运算中很常用的运算符，它表示两个向量对应坐标的乘积的和:
func +* (left: Vector2D, right: Vector2D) -> Double {
return left.x * right.x + left.y * right.y
}
但是编译器会给我们一个错误：Operator implementation without matching operator declaration
这是因为我们没有对这个操作符进行声明。之前可以直接重载像 +，-，* 这样的操作符，是因为 Swift 中已经有定义了，如果我们要新加操作符的话，需要先对其进行声明，告诉编译器这个符号其实是一个操作符。
添加如下代码：
precedencegroup DotProductPrecedence {
associativity: none
higherThan: MultiplicationPrecedence
}
infix operator +*: DotProductPrecedence
precedencegroup：定义了一个操作符优先级别
associativity：定义了结合律，即如果多个同类的操作符顺序出现的计算顺序
higherThan： 运算的优先级，点积运算是优先于乘法运算的
infix：表示要定义的是一个中位操作符，即前后都是输入