泛函编程（1）－泛函编程是如何实现的

  泛函编程就是把函数组合起来形成一个完整的程序。可想而知，函数组合的过程可以是曲折的，形成的程序可以是复杂的。那么泛函编程又是如何保证一个复杂的函数组合程序是正确无误的呢？首先，泛函编程的函数组合（Functional Composition）遵循一定的数学定律（Mathematical Laws)，这保证了组成的函数具备要求的行为特征（Behavior）。再者，所有组件函数都必须具备行为不可变化特性，即无论在任何场合，都不会因为产生了不同的最终结果而影响它们的行为。如果是这样，组合函数的行为都是可预知的，那么它们在程序中的作用也就可控了。这个什么不可变化特性解释的够绕的了吧？实际上这也是泛函编程的重点所在，我看还是要解释清楚才行。

    泛函程序是由纯函数组成。所谓纯函数（Pure Function）是指这个函数的结果完全或只依赖它的输入。对于任何一个输入值只会产生一个唯一的相同结果，而不会因为什么其它的原因影响而变成另一个不同的结果。一个函数是由一个或多个表达式组成。组成一个纯函数的表达式都必须是可以“等量替换“的，意思是每个表达式都可以用这个表达式的结果替代而不会影响整个函数的行为结果。我抛开了英文Referencial Transparent的字面意思把它翻译成”可等量替换的“。我们可以通过”等量替换“方式来分析理解函数行为。纯函数（Pure Function）只依赖输入产生结果，不会造成任何”附带影响“（Side Effect）。所谓”附带影响“是指计算一个表达式后影响了函数的结果。因为泛函程序是由纯函数组成，纯函数是”可等量替换的“，具备行为不可变化特性，所以能保证泛函程序的正确性。

   无“附带影响”、可“等量替换”作为泛函程序正确性的保障，或许在这里应该用一些实例来说明：

先来个超简单的例子：这个表达式 1+1=2够简单了吧。在Scala语言中 “+” 是个函数名称，我们可以确定这个“＋”函数是个纯函数，因为我们可以放心的用结果2来“等量替代” 表达式1+1。

再来个比较像样的例子：

1 val x = "Hello, World"
2 x: java.lang.String = Hello, World
3 scala> val r1 = x.reverse
4 r1: String = dlroW ,olleH
5 scala> val r2 = x.reverse
6 r2: String = dlroW ,olleH

我们试着把 r1 和 r2 中的 x 用 x 的结果 "Hello, World"来替代：

1 val r1 = "Hello, World".reverse
2 r1: String = dlroW ,olleH
3 scala> val r2 = "Hello, World".reverse
4 r2: String = dlroW ,olleH

r1和r2的值没有改变。那么我们可以说x是可“等量替换“的。实际上r1和r2也都是可”等量替换“的，当它们出现在一些更大的程序中时我们同样可以运用”等量替换“而不改变程序的行为。

那么再来个反面教材：

1 val x = new StringBuilder("Hello")
2 x: java.lang.StringBuilder = Hello
3 scala> val y = x.append(", World")
4 y: java.lang.StringBuilder = Hello, World
5 scala> val r1 = y.toString
6 r1: java.lang.String = Hello, World
7 scala> val r2 = y.toString
8 r2: java.lang.String = Hello, World

当我们把 y 用它的表达式替代后：

1 val x = new StringBuilder("Hello")
2 x: java.lang.StringBuilder = Hello
3 scala> val r1 = x.append(", World").toString
4 r1: java.lang.String = Hello, World
5 scala> val r2 = x.append(", World").toString
6 r2: java.lang.String = Hello, World, World

显然，虽然r1和r2都等于y，但把y用它的结果x.append(", World")替换后r1 ≠ r2。这说明StringBuilder.append不是一个纯函数，我们决不能用它来进行函数组合（Function Composition），因为组成的程序行为是不可预料的。

 从以上的例子中我们还可以得出结论：泛函程序能用正常的逻辑来理解，它的作用是可预测的，不容易出现粗心错误，可以放心使用。

再往深处想一下，上面例子StringBuilder.append之所以不是纯函数是因为StringBuilder是一个内容可以改变的数据结构（data structure），是"可改变的“(mutable)数据结构。泛函编程要求尽量使用”不可改变的“（Immutable）数据结构来保证程序的纯洁性。泛函编程就好像是使用”不可改变的“数据结构过程的挣扎，起码对我来说是这样的。

在这篇的结尾顺便示范一下泛函编程的风格：

下面这个例子是我们熟悉的OOP风格：

 1 def createErrorMessage(errorCode: Int) : String = {
 2    var result : String = _          //声明一个变量
 3    errorCode match {                //根据不同情况重新对变量result赋值
 4        result = "Network Failure"   // 对变量result赋值
 5      case 2 =>
 6        result = "I/O Failure"       // 对变量result赋值
 7      case _ =>
 8       result = "Unknown Error"      // 对变量result赋值
 9    }
10    return result;            // 返回结果
11 }

以上是典型的指令式编程（Imperative Programming）；通过改变变量值来实现程序的状态转变。看看泛函编程例子：

1 def createErrorMessage(errorCode: Int) : String = errorCode match {
2           case 1 => "Network Failure"
3           case 2 => "I/O Failure"
4           case _ => "Unknown Error"
5 }

首先，没有中间变量。整个函数简洁明了的多。不经过中间变量直接返回结果；这就是泛函编程的一个风格特征。