前言

我之前上学时和工作中所接触的编程语言，C++、Java、Objective-C，全部都是面向对象的语言，直到学习了Swift。

通过学习和在App中的实践，感觉Swift跟我们以前常用的Objective-C不太一样，苹果虽然把它定义成一个Protocol-Oriental的语言，但它实际上更像是一个多范式的语言，我们可以用它来做一些之前不能做或者不太方便做的事情，比如Functional、Reactive等等这些范式。尤其是当我查阅一些大牛写的金光闪闪的源码的时候，发现很多的都是FRP的，而且他们的API也跟Objective-C相比有了很大的变化，之所以会有很大变化，是因为语言本质上是不同的。虽然用Swift或者Objective-C都是在写iOS的App，但是当语言发生变化的时候，如果我们的思维没有发生变化，那么我们的思维就是落后于语言的，我们只不过是用Swift在写Objective-C的代码而已。

FRP是最近很火的一个词，很多业内大神都在说这个词，把它描绘成一个很NB的东东，但跟我们有什么关系呢？

比如我们说函数式编程，就要说高阶函数，就是一个函数可以当做一个值，可以作为函数的参数，也可以作为函数的返回值。或者我们说，函数式编程就是用组合的方式，把很多小函数组合成一个非常NB的函数，然后一次性帮你解决所有问题。或者是柯里化，不可变状态，引用透明，惰性求值，递归，等等等等这些函数式特性。

我在学习函数响应式编程的时候充满了好奇，尤其是它的一些变体，比如Rx系列，RAC等等。但真正学习起来，发现学习函数响应式编程其实还是挺难的，尤其是缺少好的资料的时候。很多资料都是在介绍函数响应式编程如何如何好，或者是介绍各种Rx库该如何使用。

其实学习过程中，最难的部分是如何以函数响应式的方式来思考，更多的意味着要摒弃那些老旧的命令式和状态式的典型编程习惯，并且强迫自己的大脑以不同的方式来运作，但是网上很少有这样的教程文章。

什么是函数响应式编程

我查阅了wikipedia中关于函数响应式编程的解释：

Functional reactive programming (FRP) is a programming paradigm for reactive programming (asynchronous dataflow programming) using the building blocks of functional programming (e.g. map, reduce, filter).

函数响应式编程是一个使用函数式编程（例如map，reduce，filter）构建的响应式编程（异步数据流编程）的编程范式。

In computing, reactive programming is an asynchronous programming paradigm concerned with data streams and the propagation of change.

在计算中，响应式编程是一种与数据流和变更传播有关的异步编程范式。

In computer science, functional programming is a programming paradigm—a style of building the structure and elements of computer programs—that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.

在计算机科学中，函数式编程是一种编程范式，它是一种构建计算机程序结构和元素的方式，它将计算视为对数学函数的评估，并避免了变化状态和可变数据。

看完之后有种晕晕的感觉，翻来覆去就说的是那些东东，而且我们注意到，这几段解释都提到了一个词：paradigm，翻译作范式。那什么又是范式呢？

范式

Paradigm.png

这些是常见的编程范式和它们的关系。Reactive Programming也是一种声明式的编程范式，“继承”自Dataflow Programming。它认为说，一个应用的组织形式，应该是针对那些数据流做一些处理和响应。当结合了函数式和响应式编程的特点，就产生了Functional Reactive Programming这个东西。

等等，到这里说了这么多，还是没有解释明白到底什么是范式。

我理解的范式，是一种思维模式，也就是THINKING。

为什么这么说呢？当我们在用面向对象编程的时候，其实我们是在说，我把我的世界认为是类和对象的世界，对象有某个特定的类型，对象和对象之间有某种联系，对象也有特定的行为。经典的Java、C++、Objective-C，都是这种形式，于是我们的程序就跑起来了，界面就产生了。它的核心就是说：我把我们的程序世界认为是有很多很多对象，并且他们相互作用的一个世界，所以我们说这是面向对象编程，是我们的一种思维模式。

Functional Programming也一样是一种思维模式，它认为我们一个程序是一个求值过程，我们拿到一个值，可以对它进一步求值，就产生了一个个的function。它认为一个程序世界是由function组成的世界，我们们把一个数据从源头输入进去，经过一个一个function处理并向下传递，像一个个数据管道接起来一样流过去。

其实我认为就模块复用性上来说，函数式编程要强于面向对象编程。因为面向对象的本质，是把数据和行为（属性和方法）打包在一起，组成类和对象，它通过继承和抽象，给我们提供多态的行为（面向对象的核心是多态）。函数式编程，是把一个个的函数像链条一样组合起来，这种思维模式使得你需要去用更细粒度去做抽象和模块化。

函数式编程

Talk is cheap, show me the code. 那么我们就先从Hello world的代码开始看起。

3.times { print("hello world") }

一个不会编程的人看到这段代码，肯定会知道它的意思是把“hello world”打印3遍。相比于指令式的for循环，可读性和逼格都一下子增强了好几个等级。

指令式编程，其实是让我们人像一个机器一样去思考。为什么这样说？看下面这段代码。

let nums = [1, 2, 3, 4, 5, 6, 7]
var strs = [String]()
for var i = 0; i < nums.count; i++ {
    strs.append(String(nums[i]))
}

这段代码，其实就是把我们的思维映射到了CPU模型上。一个机器工作的时候，它也需要开辟一块内存，然后不断变更一个寄存器里的值，通过这个值的递增做循环，然后把原数据从原数组中取出，开辟字符串的内存并存入指定的值，然后插入到空数组里。其实在写这段代码的时候，我们的思维都是像CPU一样地去工作，但是当我们写多了之后，会觉得这很自然。但真的是这样吗？

作为一个程序员，其实我们可能更希望尝试像一个人一样去思考，所以我们来看看声明式的编程：

let nums = [1, 2, 3, 4, 5, 6, 7]
let strs = nums.map(String.init)

且不说代码行数比之前短了很多，最重要的是我们的思维模式产生了变化，我们可以用人类的思考方式去解决这个问题。我们从原来的面相CPU面相机器编程，变成了函数式声明式的编程，我们告诉编译器，我要一个字符串数组，它是从一个int数组映射过来的。这个映射关系其实就是函数式编程的本质，或者说是思维源头。当我们这么做的时候，其实我们是在做数学，而数学是人类发明出的一个抽象工具，来把宇宙的所有东西想要框定进去（虽然数学可能做不到，但人类没有比数学更高级的抽象工具了）。

你肯定觉得还不够，那么再来一个例子，我们就说面试中经常提到的快速排序。我们都知道快速排序的原理：取一个基准值，将比基准值小的值放在基准值左边，将比基准值大的值放在基准值右边，再对左右两部分各自递归。好了，我们先看看C++实现：

void qsort(T lst[], int head, int tail) {    
    if (head >= tail) return ;

    int i = head, j = tail;

    T pivot = lst[head];  // 通常取第一个数为基准

    while (i < j) { // i,j 相遇即退出循环
        while (i < j && lst[j] >= pivot) j--;
        lst[i] = lst[j];    // 从右向左扫描，将比基准小的数填到左边
        while (i < j && lst[i] <= pivot) i++;
        lst[j] = lst[i];    //  从左向右扫描，将比基准大的数填到右边
    }

    lst[i] = pivot; // 将 基准数 填回

    qsort(lst, head, i - 1);    // 以基准数为界左右分治
    qsort(lst, j + 1, tail);
}

我相信你在看这段代码的时候肯定和我一样，脑海中出现了两个指针i和j，一个指向数组头，一个指向数组尾，指向数组头的指针往右移，指向数组尾的指针往左移，然后balabala……
我们看看声明式的代码是什么样的：

extension Array where Element: Comparable {
    func quickSort() -> Array<Element> {
        guard self.count >= 2 else {
            return self
        }
        let base = self[0]
        let lesser = self.filter { $0 < base }
        let equal = self.filter { $0 == base }
        let greater = self.filter { $0 > base }
        return lesser.quickSort() + equal + greater.quickSort()
    }
}

不仅仅是不需要任何注释，从代码里就读出了快速排序的思路，更关键的是，我们终于可以直接使用人脑的思维写出了这样的代码，而不是再以CPU的思维来写代码了。

更高级的抽象

函数式带给我们的，其实是一种更加抽象的封装。比如Swift中的Array、Dictionary、Optional等等这些容器类型，都map和flatMap方法。当我们对它们进行map的时候，它门内部都是对容器内部的值去进行计算（根据参数传入的函数进行计算），它的抽象并不是抽象出一堆的数据结构，不是抽象出一堆状态或方法，它抽象的是一个计算过程，也就是说我们可以对这个容器这个值进行任意计算。

下面我们看一个常见问题，通常在处理异步回调的时候会这么写：

// Async callback
(value: T?, error: ErrorType?) -> Void
if let error = error {
    // handle error
} else if let value = value {
    // handle value
} else {
    // all nil?
}
// all non nil?

显然它的API设计显得有些烦人，所以我们定义ResultType解决这个问题。

// 定义Result解决这个问题
enum Result<Value> {
    case Failure(ErrorType)
    case Success(Value)
}
  
(result: Result<T>) -> Void
switch result {
case let .Error(error):
    // handle error
case let .Success(value):
    // handle value
}

ResultType已经帮助我们解决了很棘手的问题，但其实它还可以提供给我们更强大更抽象的东西：实现map和flatMap。

enum Result<Value> {
    func flatMap<T>(transform: Value -> Result<T>) -> Result<T> {
        switch self {
        case let .Failure(error):
            return .Failure(error)
         
        case let .Success(value):
            return transform(value)
        }
    }
  
    func map<T>(transform: Value -> T) -> Result<T> {
        return flatMap { .Success(transform($0)) }
    }
}

看看它是如何强大的。

// 根据data生成图片
func toImage(data: NSData) -> Result<UIImage>
  
// 给图片设置alpha
func addAlpha(image: UIImage) -> Result<UIImage>
  
// 给图片切割圆角
func roundCorner(image: UIImage) -> Result<UIImage>
  
// 给图片做模糊处理
func applyBlur(image: UIImage) -> Result<UIImage>
  

// 基于ResultType的链式编程
toImage(data)
    .flatMap {
        return addAlpha
    }.flatMap {
        return roundCorner
    }.flatMap {
        return applyBlur
    }

不知道大家发现了没有，如果这里面把flatMap函数的名字改成then，简直是像极了JavaScript中赫赫有名的Promise。对的，Promise和我们定义的ResultType的基本原理一样，都是Monad（单子）。

Monad

Monad是一个可怕的名词，为什么说它可怕？google一下得到的解释是：

一个自函子范畴上的幺半群

是不是一个头已经两个大了，你说可怕不可怕？

在程序员界，让人害怕最多的可能就是两个词：指针和Monad，而指针和Monad实际上都是一个高级抽象的过程。

好了，不吓人了，抛开那些难懂的概念，简单地说，Monad其实就是一个容器，实现了那两个方法：map和flatMap。

比如我们上面说了，Swift中Array、Dictionary、Optional等等这些容器类型，都map和flatMap方法，所以他们都是Monad。
比如PromiseKit，它可以把异步计算的结果给封装在一个数据里面，等到这个值真正产生的时候，就可以拿出结果。Promise的核心方法：两个then，跟我们Array中的flatMap、map完全没有区别，Promise也是一个Monad。
再比如Reative Programming，它能够让我们对Observable做一些计算、封装等等。其实它里面一系列的方法，都是这样的：当我们去observe，combine的时候，就是拿到一个Observable对象，传进去一个闭包，对它里面拥有的值去进行一些操作，然后返回另外一个Observable。所有的这些，其实就是把Reactive的概念（可序列化、可响应的值）用Monad的形式封装起来，提供给我们一个对计算过程的抽象，我们就可以基于它来做一些流式的开发。

Monad帮我们把计算过程抽象出来，同时当出现任何错误的时候，没有任何额外多余的计算步骤，直接把错误返回。

小结

函数式编程给我们的，是对计算的更高级的抽象，当我去学习尝试各种函数式编程技巧，这些技巧不是最重要的，最重要的是我们的思维会得到改变。

下一次分享，我会更加详细地介绍Monad和她的姐妹：Functor、Applicative。