第5章 函数与函数式编程

凡此变数中函彼变数者，则此为彼之函数。 ( 李善兰《代数学》)

函数式编程语言最重要的基础是λ演算（lambda calculus），而且λ演算的函数可以传入函数参数，也可以返回一个函数。函数式编程 (简称FP) 是一种编程范式（programming paradigm）。

函数式编程与命令式编程最大的不同是：函数式编程的焦点在数据的映射，命令式编程（imperative programming）的焦点是解决问题的步骤。函数式编程不仅仅指的是Lisp、Haskell、 Scala等之类的语言，更重要的是一种编程思维，解决问题的思考方式，也称面向函数编程。

函数式编程的本质是函数的组合。例如，我们想要过滤出一个List中的奇数，用Kotlin代码可以这样写

package com.easy.kotlin

fun main(args: Array<String>) {
    val list = listOf(1, 2, 3, 4, 5, 6, 7)
    println(list.filter { it % 2 == 1 }) // lambda表达式
}

这个映射的过程可以使用下面的图来形象化地说明

而同样的逻辑我们使用命令式的思维方式来写的话，代码如下

package com.easy.kotlin;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import static java.lang.System.out;

public class FilterOddsDemo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7});
        out.println(filterOdds(list)); // 输出：[1, 3, 5, 7]
    }

    public static List<Integer> filterOdds(List<Integer> list) {
        List<Integer> result = new ArrayList();
        for (Integer i : list) {
            if (isOdd(i)) {
                result.add(i);
            }
        }
        return result;
    }

    private static boolean isOdd(Integer i) {
        return i % 2 != 0;
    }
}

我们可以看出，函数式编程是简单自然、直观易懂且美丽优雅的编程风格。函数式编程语言中通常都会提供常用的map、reduce、filter等基本函数，这些函数是对List、Map集合等基本数据结构的常用操作的高层次封装，就像一个更加智能好用的工具箱。

5.1 函数式编程简介

函数式编程是关于不变性和函数组合的编程范式。函数式编程有如下特征

• 一等函数支持（first-class function）：函数也是一种数据类型，可以当做参数传入另一个函数，同时一个函数也可以返回函数。
• 纯函数（pure function）和不变性（immutable）：纯函数指的是没有副作用的函数（函数不去改变外部的数据状态）。例如，一个编译器就是一个广义上的纯函数。在函数式编程中，倾向于使用纯函数编程。正因为纯函数不会去修改数据，同时又使用不可变数据，所以程序不会去修改一个已经存在的数据结构，而是根据一定的映射逻辑创建一份新的数据。函数式编程是去转换数据而非修改原始数据。
• 函数的组合（compose function）：在面向对象编程中，是通过对象之间发送消息来构建程序逻辑；而在函数式编程中，是通过不同函数的组合构建程序逻辑。

5.2 声明函数

Kotlin中使用 fun 关键字来声明函数，其语法实例如下图所示

为了更加直观的感受到函数也可以当做变量来使用，我们声明一个函数类型的变量 sum 如下

>>> val sum = fun(x:Int, y:Int):Int { return x + y }
>>> sum
(kotlin.Int, kotlin.Int) -> kotlin.Int

我们可以看到这个函数变量 sum 的类型是

(kotlin.Int, kotlin.Int) -> kotlin.Int

这个带箭头（ -> ）的表达式就是一个函数类型，表示一个输入两个Int类型值，输出一个Int类型值的函数。我们可以直接使用这个函数字面值 sum

>>> sum(1,1)
2

从上面的这个典型的例子我们可以看出，Kotlin也是一门面向表达式的语言。既然 sum 是一个代表函数类型的变量，稍后我们将看到一个函数可以当做参数传入另一个函数中（高阶函数）。

当然，我们仍然可以像C/C++/Java中一样，直接带上函数名来声明一个函数

fun multiply(x: Int, y: Int): Int {
    return x * y
}

multiply(2, 2) // 4

5.3 lambda表达式

我们在本章开头部分讲到了这段代码

val list = listOf(1, 2, 3, 4, 5, 6, 7)
list.filter { it % 2 == 1 }

这里的filter函数的入参 { it % 2 == 1 } 就是一段 lambda表达式。实际上，因为filter函数只有一个参数，所有括号被省略了。所以，filter函数调用的完整写法是

list.filter ({ it % 2 == 1 })

其中的filter函数声明如下

public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>

其实，filter函数的入参是一个函数 predicate: (T) -> Boolean 。 实际上，

{ it % 2 == 1 } 

是一种简写的语法，完整的lambda表达式是这样写的

{  it -> it % 2 == 1 } 

如果拆开来写，就更加容易理解

>>> val isOdd = { it: Int -> it % 2 == 1 } // 直接使用lambda表达式声明一个函数，这个函数判断输入的Int是不是奇数
>>> isOdd
(kotlin.Int) -> kotlin.Boolean // isOdd函数的类型
>>> val list = listOf(1, 2, 3, 4, 5, 6, 7)
>>> list.filter(isOdd) // 直接传入isOdd函数
[1, 3, 5, 7]

5.4 高阶函数

其实，在上面的代码示例 list.filter(isOdd) 中，我们已经看到了高阶函数了。现在我们再添加一层映射逻辑。我们有一个字符串列表

val strList = listOf("a", "ab", "abc", "abcd", "abcde", "abcdef", "abcdefg")

然后，我们想要过滤出字符串元素的长度是奇数的列表。我们把这个问题的解决逻辑拆成两个函数来组合实现

val f = fun (x: Int) = x % 2 == 1 // 判断输入的Int是否奇数
val g = fun (s: String) = s.length // 返回输入的字符串参数的长度

我们再使用函数 h 来封装 “字符串元素的长度是奇数” 这个逻辑，实现代码如下

val h = fun(g:  (String) -> Int, f: (Int) -> Boolean):  (String) -> Boolean {
    return { f(g(it)) }
}

但是，这个 h 函数的声明未免有点太长了。尤其是3个函数类型声明的箭头表达式，显得不够简洁。不过不用担心。

Kotlin中有简单好用的 Kotlin 类型别名, 我们使用 G，F，H 来声明3个函数类型

typealias G = (String) -> Int
typealias F = (Int) -> Boolean
typealias H = (String) -> Boolean

那么，我们的 h 函数就可简单优雅的写成下面这样了

val h = fun(g: G, f: F): H {
    return { f(g(it)) } // 需要注意的是，这里的 {} 是不能省略的
}

这个 h 函数的映射关系可用下图说明

函数体中的这句代码 return { f(g(it)) } ， 这里的 {} 它代表这是一个lambda表达式，返回的是一个 (String) -> Boolean 函数类型。如果没有 { } ， 那么返回值就是一个布尔类型Boolean了。

通过上面的代码例子，我们可以看到，在Kotlin中，我们可以简单优雅的实现高阶函数。OK，现在逻辑已经实现完了，下面我们在 main 函数中运行测试一下效果。

fun main(args: Array<String>) {
    val strList = listOf("a", "ab", "abc", "abcd", "abcde", "abcdef", "abcdefg")
    println(strList.filter(h(g, f))) // 输出：[a, abc, abcde, abcdefg]
}

当你看到 h(g, f) 这样的复合函数的代码时，你一定很开心，感到很自然，这跟数学公式真是很贴近，简单易懂。

本章小结

在Kotlin中，支持函数作为一等公民。它支持高阶函数、lambda表达式等。我们不仅可以把函数当做普通变量一样传递、返回，还可以把它分配给变量、放进数据结构或者进行一般性的操作。在Kotlin中进行函数式编程相当简单自如。