导读
判断一个语言原生是否支持函数式编程，主要看它的函数是否first-class function，函数作为第一对象。
类型：规定了变量可以取的值得范围，以及该类型的值可以进行的操作。根据类型的值的可赋值状况，可以把类型分为三类：
1、一级的（first class）。该等级类型的值可以传给子程序作为参数，可以从子程序里返回，可以赋给变量。大多数程序设计语言里，整型、字符类型等简单类型都是一级的。
2、二级的（second class）。该等级类型的值可以传给子程序作为参数，但是不能从子程序里返回，也不能赋给变量。
3、三级的（third class）。该等级类型的值连作为参数传递也不行。
OC并不是函数式语言，但通过扩展可以让其支持一些函数式语言的特性。如ReactiveCocoa，大量的使用Block来实现函数式语言的特点。
与OC不同的是，Swift可以说是函数式语言，它的func是第一公民。
// 为变量赋值
var aFunc = someFunc
// 作为函数输入
func inputFunc(_ f: ()->Void) { f() }
// 作为函数输出
func outputFunc() -> () -> Void { return someFunc }
Functor
来自Wiki的解释
In mathematics, a functor is a type of mapping between categories which is applied in category theory. Functors can be thought of as homomorphisms between categories. In the category of small categories, functors can be thought of more generally as morphisms.
这是数学上的解释，比较难懂。但与编程上还是有一些区别的。
Functor一般定义:
- 应用在一个“包装过”的值V上
- 接受一个参数，该参数是一个普通函数，接收一个普通值并返回一个普通值
在Swift里Functor可以看作是一种数据类型，该类型的特征是有一个map函数，例如Optional。Optional的map函数接受一个(T)->U并返回一个u?从结果来分析，Optional的map函数对Self进行了解包，如果有值则将输入的函数应用到这个值上并产生一个新值，最后这个值经过包装后返回。
let a = Optional(10)
let b = a.map { $0 + 1 }
print(a, b)
// Optional(10) Optional(11)
除了Optional，Array也是一个Functor。
let a = [1, 2, 3, 4]
let b = a.map{ "\($0)" }
print(a, b)
// [1, 2, 3, 4] ["1", "2", "3", "4"]
另外RACSignal也是一个Functor，可以将它看作是一个数据类型，它包装了一个next和一个error值。有趣的是RACSignal的值是被定义为未来将要产生的。
Applicative
和Functor不同的是，Applicative是将一个包装后的函数应用在一个包装后的值上。
Applicative一般定义
- 应用在一个“包装过”的值V上
- 输入一个参数，该参数是一个“包装过后”的普通函数
Swift里并没有实现Applicative的类，但可以简单扩展一下。
extension Optional {
func apply<U>(f: ((Wrapped) -> U)?) -> U? {
switch f {
case .some(let someF): return self.map(someF)
case .none: return .none
}
}
}
extension Array {
func apply<U>(fs: [(Element) -> U]) -> [U] {
var result = [U]()
for f in fs {
for element in self.map(f) {
result.append(element)
}
}
return result
}
}
对于Optional来说添加Applicative的支持意义不是很大。但对于数组来说是一个不错的扩展。apply函数先历遍传入的函数数组，然后将每个函数都应用到数组的每个值上。
let a = [1, 2, 3]
func plusOne(_ a: Int) ->Int {
return a + 1
}
func plusTwo(_ a: Int) ->Int {
return a + 2
}
func plusThree(_ a: Int) ->Int {
return a + 3
}
let b = a.apply(fs: [plusOne, plusTwo, plusThree])
print(b)
// [2, 3, 4, 3, 4, 5, 4, 5, 6]
Monad
对于学RAC的人来说，了解Monad的概念是非常重要的。Monad的一个标识是实现Bind或叫flatMap的函数。
Monad的一般定义:
- 应用在一个“包装过”的值V上
- 传入一个参数，该参数是一个函数，该函数接受一个普通值并返回一个“包装”过的值
Swift里的Optional是这么定义flatMap的
public func flatMap<U>(_ transform: (Wrapped) throws -> U?) rethrows -> U?
Optional的map和flatMap区别并不是很大，但考虑一下下面的场景。在Optional上用map有机会产生嵌套的Optional，要判断是否为nil就会比较尴尬了。所以用flatMap会更安全一点。
let a = Optional(10)
let b = a.map { $0 + 1 }
let c = a.map { value in
return value == 10 ? nil : value
}
let d = a.flatMap { value in
return value == 10 ? nil : value
}
print("b == \(b)")
// b == Optional(11)
print("c == \(c)")
// c == Optional(nil)
if let e = c {
// 嵌套的Optional，即使用Optional bind也无法判断里面是否为nil
print("e == \(e)")
// e == nil
}
if let f = d {
// 这里不会打印，因为判断到f为nil。
print("f == \(f)")
}
Swift的数组也是一个Monad，但它有两种实现flatMap的方式
public func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
public func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
从函数原型来看，两个函数长得很像。区别在于泛型上，一个函数限定了数组必须是嵌套的，第二个函数则没限定。下面看看实例。
let a:[Int?] = [1, 2, nil, 4]
let b = [[1, 2], [3, 4]]
let c = a.flatMap { $0 }
let d = b.flatMap { $0 }
print(c)
// [1, 2, 4]
print(d)
// [1, 2, 3, 4]
可以看出两个flatMap的区别了，对于第一个函数，它与map最大的区别是，它会将数组里的元素进行解包并过滤掉nil。第二个函数则将二维数组打平。
写在最后
函数式编程的三兄弟是一个比较大的主题，我的理解只是冰山一角，但带上这些片面的理解能让我更好的理解map, flatMap这些函数的意义，还有RAC。下一遍将讨论一下RAC和Monad。
