Kotlin函数式编程（二） 高阶函数

在上一节中，我们提到了高阶函数的定义：高阶函数是一个接受其他函数作为参数，或是返回其他函数的函数。Kotlin标准库中的集合类，包括Java8的Stream api，都提供了用于操作数据结构的高阶函数，如map，filter等。在讲解这些集合操作之前，让我们先来了解一下高阶函数。
首先是一个非常简单的高阶函数——always：

fun <A> always(a: A): (Any?) -> A = { a }

其中，返回值类型(Any?) -> A表明返回值是一个函数，这个函数接受可空的Any类型的参数，返回一个A类型的值。always返回一个Lambda，而这个Lambda的返回值恒为a（因为Lambda的参数没有作用，所有这里参数列表和“->”被省略了）。
always可以帮我们构建一些简单的函数，如：alwaysTrue：

val alwaysTrue = always(true)

fun main(args: Array<String>) {
    alwaysTrue(false).log() // Log true
}

不管传递什么参数给alwaysTrue，都将返回true。
类似于alwaysTrue这样，用于判断一个表达式真伪的函数，我们称之为断言。断言是一个十分常见的函数类型，我们可以为它创建一个类型别名：

typealias Pred<T> = (T) -> Boolean

我们可以编写更多实用的断言函数，比如isEquals：

fun <A> isEquals(right: A): Pred<A> = { it == right }

isEquals可以这么使用：

fun main(args: Array<String>) {
    isEquals(1)(1).log() // Log true
    isEquals(1)(0).log() // Log false
}

利用isEquals，我们可以筛选一个列表中的某个特定值：

fun main(args: Array<String>) {
    val list = listOf(1, 1, 2, 1, 3, 5, 1)
    list.filter(isEquals(1)).log() // Log [1, 1, 1, 1]
    // 也可以使用Lambda：
    list.filter { it == 1 }.log()
}

如果要筛选所有不等于1的元素怎么办呢？我们可以编写一个not函数，用来反转一个断言的结果：

fun <A> not(pred: Pred<A>): Pred<A> = { !pred(it) }

fun main(args: Array<String>) {
    val list = listOf(1, 1, 2, 1, 3, 5, 1)
    list.filter(not(isEquals(1))).log() // Log [2, 3, 5]
}

not(isEquals(1))这样函数嵌套的写法看起来有点丑，我们可以利用Kotlin提供的运算符重载功能：

operator fun <A> Pred<A>.not(): Pred<A> = { !this(it) }

fun main(args: Array<String>) {
    val list = listOf(1, 1, 2, 1, 3, 5, 1)
    list.filter(!isEquals(1)).log() // Log [2, 3, 5]
}

看起来清爽多了。
我们可以像结合布尔值一样，使用“与”或“或”结合多个断言：

infix fun <A> Pred<A>.and(other: Pred<A>): Pred<A> =
        { this(it) and other(it) }

infix fun <A> Pred<A>.or(other: Pred<A>): Pred<A> = 
        { this(it) or other(it) }

利用断言，我们可以实现简单的流程控制：

fun <A, B> doIf(pred: Pred<A>, action: (A) -> B): (A) -> B? =
        { if (pred(it)) action(it) else null }

fun main(args: Array<String>) {
    val action = doIf(isEquals(1)){ it.log() }
    action(1) // Log 1
    action(2) // Log Nothing
}

doIf返回的函数可能返回空值，不能很好的和forEach等方法配合，我们可以编写setDefault函数进行适配：

fun <A, B> ((A) -> B?).setDefault(value: B): (A) -> B =
        { this(it) ?: value }

fun main(args: Array<String>) {
    val action = doIf(isEquals(1)){ it.log() }
    listOf(1, 1, 2, 3, 4, 5, 1).forEach(action.setDefault(Unit))
    // Log 1 1 1
}

?:表示，如果表达式的值是null，则返回?:右边的值，否则返回左边的值。
如果我们想实现类似Java中switch的功能怎么办呢？dispatch（分派）可以实现这一点：

fun <A, B : Any> dispatch(vararg fs: (A) -> B?): (A) -> B? =
        { a -> fs.asSequence().mapNotNull{ it(a) }.firstOrNull() }

fun main(args: Array<String>) {
    val action = dispatch(
            doIf(isEquals(1)){ "One" },
            doIf(isEquals(2)){ "Two" },
            doIf(alwaysTrue){ "Other" }
    )
    listOf(1, 1, 2, 3, 4, 5, 1).map(action).log()
    // Log [One, One, Two, Other, Other, Other, One]
}

dispatch函数的实现较为复杂。简单的说，dispatch接受一组函数作为参数（vararg关键字表明一个函数可以接受任意数量的参数），dispatch生成的函数会对其参数依次调用函数列表中的每一个函数，当返回值不为null时就直接将其返回，否则调用下一个函数。为了便于理解，我们来看看等效的过程式代码：

fun <A, B : Any> dispatch(vararg fs: (A) -> B?): (A) -> B? {
    fun action(a: A): B? {
        for (f in fs) {
            val r = f(a)
            if (r != null) return r
        }
        return null
    }
    return ::action
}

*关于sequence及其方法我们会在下一节集合操作中详细介绍。
组合dispatch，doIf，断言，setDefault能够封装十分复杂的逻辑，这正是函数式编程简洁和灵活性的体现。像action这样通过其他函数组合而成的函数我们称它为组合子，而无法通过其他函数组合的函数则称为原语。