函数式编程

什么是函数式编程，以下是维基百科给出的答案：

函数式编程（英语：functional programming）或称函数程序设计、泛函编程，是一种编程范式，它将电脑运算视为函数运算，并且避免使用程序状态以及易变对象。其中，λ 演算（lambda calculus）为该语言最重要的基础。而且，λ 演算的函数可以接受函数当作输入（引数）和输出（传出值）。比起指令式编程，函数式编程更加强调程序执行的结果而非执行的过程，倡导利用若干简单的执行单元让计算结果不断渐进，逐层推导复杂的运算，而不是设计一个复杂的执行过程。

这种文趋趋的概念，了解过后有个印象就好了，下面这句话才重要：

在函数式编程中，函数是第一类对象，意思是说一个函数，既可以作为其它函数的参数（输入值），也可以从函数中返回（输入值），被修改或者被分配给一个变量。

这不就是高阶函数的定义吗？是的，不过，函数式编程是一种编程范式，而高阶函数是函数式编程的基本技术，换句话说：函数式编程包括但不限于高阶函数这一种技术，还有闭包、柯里化、偏函数等等。

闭包

闭包就是能够读取其他函数内部变量的函数。对于支持函数式编程的语言来说，可以在一个函数 A 内部再定义一个函数 B，函数 B 可以访问函数 A 中的成员，通常函数 A 的返回结果就是函数 B，并且闭包会延长函数 A 的生命周期（函数 A 中的成员不会被回收）。

个人理解：闭包中两个函数的关系，跟内部类与外部类的关系很像，不过闭包较为轻量。

我们可以使用闭包来实现斐波那契数列，斐波那契数列的核心要点就是缓存前面的结果，供后续计算使用，使用闭包正合适：

fun fib(): () -> Long {
    var prev = 0L
    var current = 1L
    return fun(): Long {
        val result = current
        current += prev
        prev = result
        return result
    }
}
fun main() {
    val fib = fib() // fib是fib()内的匿名函数
    println(fib())　// 1
    println(fib()) // 1
    println(fib()) // 2
    println(fib()) // 3
    println(fib()) // 5
    println(fib()) // 8
}

可以看到，每次调用这个 fib 匿名函数，出来的结果是不一样的，说明闭包确实可以让内部函数持有外部函数的成员，并且延长了外部函数作用域中变量的生命周期。

柯里化

什么是柯里化？贴一个维基百科对柯里化的定义：

在计算机科学中，柯里化（英语：Currying），又译为卡瑞化或加里化，是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。

假设有一个求和函数 add，它接收多个参数，满足函数柯里化的前提：

fun add(num1: Int, num2: Int): Int {
    return num1 + num2
}
fun main() {
    val result = add(1, 2)
    println(result) // 3
}

我们如何把上述函数 add 进行柯里化呢？根据柯里化的定义，我们需要把函数 add 进行两处修改：

• 参数列表：把接收多个参数转变成接收单个参数。
• 返回值：返回接收余下参数和结果的函数。

fun add(num1: Int): (Int) -> Int {
    return fun(num2: Int): Int {
        return num1 + num2
    }
}
fun main() {
    val result = add(1)(2)
    println(result) // 3
}

可以看到函数 add 的调用形式发现了变化，从 add(1, 2) 变换成了 add(1)(2)，这就是柯里化。另外，因为 Kotlin 支持智能类型推导，所以柯里化函数 add 还可以进行简化：

fun add(num1: Int) = fun(num2: Int) = num1 + num2

这变化也太神奇了吧，简化后的柯里化函数 add 让人眼前一亮。同样的，如果参数个数为 3，4，..n 个，对于 Kotlin 来说，柯里化他们也就是一把梭的事。

偏函数

偏函数（Partial function）就是把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

注意：偏函数与函数默认参数很像，但两者是有区别的。默认参数是在原函数的基础上给某些参数指定默认值，调用的时候还是原来那个函数，而偏函数一般情况下则是通过某种手段生成的新函数，后续调用的是这个新的函数。

举个例子，有一个可以构建不同编码字符串的函数 buildString：

fun buildString(byteArray: ByteArray, charsetName: String): String {
    return String(byteArray, charset(charsetName))
}
fun main() {
    val result = buildString("lqr".toByteArray(), "UTF-8")
    println(result)
}

现在编程都会使用 UTF-8 作为默认编码，所以，为了不在每次调用这个函数的时候都要传入 charsetName 这个参数，可以为函数指定默认参数解决：

fun buildString(byteArray: ByteArray, charsetName: String = "UTF-8"): String {
    return String(byteArray, charset(charsetName))
}
fun main() {
    val result = buildString("lqr".toByteArray())
    println(result)
}

如果用偏函数来处理，会有什么不同呢？可惜了，Kotlin 本身还没有提供类似 python 那种 functools.partial 用于生成偏函数的功能，不过我们可以借助扩展函数实现类似的偏函数生成功能：

// 对Function2进行扩展，partial2可以生成带有默认参数2的偏函数，partial1则是可以生成带有默认参数1的偏函数
fun <P1, P2, R> Function2<P1, P2, R>.partial2(p2: P2) = fun(p1: P1) = this(p1, p2)
fun <P1, P2, R> Function2<P1, P2, R>.partial1(p1: P1) = fun(p2: P2) = this(p1, p2)

fun main(args: Array<String>) {
    val buildStrPartial2 = ::buildString.partial2("UTF-8")
    val result = buildStrPartial2("lqr".toByteArray())
    println(result)
}

个人认为，现阶段在 Kotlin 中以这种方式使用偏函数还不如直接使用函数默认参数来的实在，对于偏函数，知道是个什么东西就好了。