前两篇说了 monad 和 functor ，这两个算是比较经常会实际使用的。
这里说的两个函数式编程 Feature ，相对就没有那么广泛的使用了。
Applicative 和 Curry ，其中 applicative 并没有在 swift 中原生集成（虽然实现起来也很容易）， Curry 在 swift 3.0 中被移除了（虽然自己实现起来还是很容易）。
这里用到的代码我都写在了 playground 里，放到了 Github 上
这里简单说一下吧。
1. Applicative
只要实现了 Apply 函数如何作用于自身，就是一个 Applivative。
Optional 的 Apply
我们可以这样对 optional 和 SequenceType 扩充一个 apply 方法：
extension Optional {
func apply<T>(f: (Wrapped -> T)?) -> T? {
if let f = f {
return self.map(f)
}
return nil
}
}
这样 Optional 就是一个 Applivative 了，我们可以这样来使用：
let b = Optional.Some(1)
let a = Optional.Some({ $0 + 1 })
b.apply(a) // 返回 Optional(2)
SequenceType 的 Apply
我们同样可以对 SequenceType 扩充一个 apply 方法
extension SequenceType {
func apply<T>(fs: [Generator.Element -> T]) -> [T] {
var result = [T]()
for f in fs {
for element in self.map(f) {
result.append(element)
}
}
return result
}
}
这样一来 SequenceType 也是 Applicative 了。
我们可以怎么使用呢？
let plusTwoAndThree = [ { $0 * 2 }, { $0 * 3 } ]
let ints = [1, 2, 3]
ints.apply(plusTwoAndThree) // 返回 [2, 4, 6, 3, 6, 9]
实践
和 functor 和 monad 类似，我们定义一个操作符 <*>
infix operator <*> { associativity left }
func <*><U, T>(f: (U -> T)?, a: U?) -> T? {
return a.apply(f)
}
func <*><S: SequenceType, T>(f: [S.Generator.Element -> T], a: S) -> [T] {
return a.apply(f)
}
然后我们就可以这样：
a <*> b
plusTwoAndThree <*> ints
2. Curry
简单地来说，Curry 就是一个生成方法的方法
比如说这里：
func operate(num: Int) -> (Int -> Int) -> Int {
return {
operate in operate(num)
}
}
这是一个接收一个 Int 参数，返回一个接受一个 Int -> Int 参数的方法，再返回 Int
这么说可能有点绕，比如我们使用这个方法：
let operateOne = operate(1) // (Int -> Int) -> Int
这里的 operateOne 就是一个生成的方法，它接受一个 Int -> Int 方法，然后返回 Int
我们可以拿这个 operateOne 这么使用：
let addOne: Int -> Int = { $0 + 1 }
let addTwo: Int -> Int = { $0 + 2 }
operateOne(addOne) // 返回2
operateOne(addTwo) // 返回3
使用 curry 能够量产方法，可以避免写一些重复的代码。
实践
在 swift 3.0 中，已经把 curry 函数移除了，详情可以见这里：
remove-currying
// Before:
func curried(x: Int)(y: String) -> Float {
return Float(x) + Float(y)!
}
像这种已经不能写了，但是可以用这种方法，也能轻易实现：
// After:
func curried(x: Int) -> (String) -> Float {
return {(y: String) -> Float in
return Float(x) + Float(y)!
}
}
但是我们不是都有机会去修改代码的，比如说一些第三方库什么的，我们可以用这样的泛型函数生成一个柯里函数：
func curry<A,B,R>(fun: (A,B) -> R) -> A -> B -> R {
return { a in { b in fun(a,b) } }
}
这么使用：
func operate(num: Int, f: Int -> Int) -> Int {
return f(num)
}
let curryOperate = curry(operate)
curryOperate(1)(addOne) // 返回 2
curry 和 applicative 也是函数式编程的重要部分，但是相对于 map 和 flatMap ，并没有在 swift 中那么多的使用，但是掌握了它们，仍然能为我们带来更好的开发思维，具体可以如何使用呢？
可以看一看我的这一篇：
