高阶函数与 lambda 表达式

高阶函数是将 函数 用作 参数 或 返回值 的函数

    一个不错的示例：是集合的函数式风格fold函数， 它接受一个初始累积值与一个接合函数，并通过将当前累积值与每个集合元素连续接合起来代入累积值来构建返回值

fun <T, R> Collection<T>.fold(
    initial: R, 
    combine: (acc: R, nextElement: T) -> R
): R {
    var accumulator: R = initial
    for (element: T in this) {
        accumulator = combine(accumulator, element)
    }
    return accumulator
}

    在上述代码中，参数 combine 具有函数类型 (R, T) -> R

    因此 fold 接受一个函数作为参数，该函数接受类型分别为 R 与 T 的两个参数并返回一个 R 类型的值

    在 for-循环内部调用该函数，然后将其返回值赋值给 accumulator

为了调用 fold，需要传给它一个 函数类型 的 实例 作为 参数

fun main() {
    //sampleStart
    val items = listOf(1, 2, 3, 4, 5)

    // Lambdas 表达式是花括号括起来的代码块。
    items.fold(0, { 
        // 如果一个 lambda 表达式有参数，前面是参数，后跟“->”
        acc: Int, i: Int -> 
        print("acc = $acc, i = $i, ") 
        val result = acc + i
        println("result = $result")
        // lambda 表达式中的最后一个表达式是返回值：
        result
    })

    // lambda 表达式的参数类型是可选的，如果能够推断出来的话：
    val joinedToString = items.fold("Elements:", { acc, i -> acc + " " + i })

    // 函数引用也可以用于高阶函数调用：
    val product = items.fold(1, Int::times)
    //sampleEnd
    println("joinedToString = $joinedToString")
    println("product = $product")
}

    而在高阶函数调用处，lambda 表达 式广泛用于此目的

Kotlin 使用类似 (Int) -> String 的一系列函数类型来处理函数的声明

val onClick: () -> Unit = …… 

这些类型具有与函数签名相对应的特殊表示法，即它们的 参数 和 返回值 ：

• 所有函数类型都有一个 圆括号 括起来的 参数类型列表 以及一个 返回类型

(A, B) -> C 表示接受类型分别为 A 与 B 两个参数并返回一个 C 类型值的函数类型

• 参数类型列表可以为空

        如 () -> A
  

• Unit 返回类型不可省略

• 函数类型可以有一个额外的 接收者类型 ，它在表示法中的 点之前 指定

        类型 A.(B) -> C 表示可以在 A 的接收者对象上以一个 B 类型参数来调用并返回一个 C 类型值的函数
  
        带有接收者的函数字面值通常与这些类型一起使用
  

• 挂起 函数属于特殊种类的函数类型，它的表示法中有一个 suspend 修饰符

        例如 suspend () -> Unit 或者 suspend A.(B) -> C
  

函数类型表示法可以选择性地包含函数的参数名： (x: Int, y: Int) -> Point 这些名称可用于表明参数的含义

    如需将函数类型指定为可空，请使用圆括号：((Int, Int) -> Int)?。

    函数类型可以使用圆括号进行接合：(Int) -> ((Int) -> Unit)

    箭头表示法是右结合的，(Int) -> (Int) -> Unit 与前述示例等价，但不等于 ((Int) -> (Int)) -> Unit

还可以通过使用类型别名给函数类型起一个别称：

typealias ClickHandler = (Button, ClickEvent) -> Unit

有时使用内联函数可以为高阶函数提供灵活的控制流

lambda 表达式与匿名函数是 函数字面值 ，即未声明的函数， 但立即做为表达式传递。考虑下面的例子：

max(strings, { a, b -> a.length < b.length })

函数 max 是一个高阶函数，它接受一个函数作为第二个参数：这是一个表达式，它本身是一个函数，即函数字面值，它等价于以下具名函数：

fun compare(a: String, b: String): Boolean = a.length < b.length

    上面提供的 lambda 表达式语法缺少的一个东西是指定函数的返回类型的能力

    在大多数情况下，这是不必要的，因为返回类型可以自动推断出来

然而，如果确实需要显式指定，可以使用另一种语法： 匿名函数

fun(x: Int, y: Int): Int = x + y

匿名函数看起来非常像一个常规函数声明，除了其 名称 省略 了。其函数体可以是表达式或代码块：

fun(x: Int, y: Int): Int {
    return x + y
}

参数和返回类型的指定方式与常规函数相同，除了能够从上下文推断出的参数类型可以省略：

ints.filter(fun(item) = item > 0)

    匿名函数的返回类型推断机制与正常函数一样：对于具有表达式函数体的匿名函数将自动推断返回类型，而具有代码块函数体的返回类型必须显式指定（或者已假定为 Unit）

请注意：

• 匿名函数参数总是在括号内传递。允许将函数留在圆括号外的简写语法仅适用于 lambda 表达式
• Lambda表达式与匿名函数之间的另一个区别是 非局部返回 的行为，一个不带标签的 return 语句总是在用 fun 关键字声明的函数中返回。这意味着：
  • lambda 表达式中的 return 将从 包含它的函数 返回
  • 而匿名函数中的 return 将从 匿名函数自身 返回

Lambda 表达式或者匿名函数（以及局部函数和对象表达式） 可以访问其 闭包 ，即在 外部作用域 中 声明 的 变量 。 在 lambda 表达式中可以修改闭包中捕获的变量：

var sum = 0
ints.filter { it > 0 }.forEach {
    sum += it
}
print(sum)

带有接收者的函数类型，可以用特殊形式的函数字面值实例化：带有接收者的函数字面值

    例如 A.(B) -> C

在这样的函数字面值内部，传给调用的接收者对象成为 隐式 的 this ，以便访问接收者对象的成员而无需任何额外的限定符，亦可使用 this 表达式 _访问接收者对象

    这种行为与扩展函数类似，扩展函数也允许在函数体内部访问接收者对象的成员

这里有一个带有接收者的函数字面值及其类型的示例，其中在接收者对象上调用了 plus ：

val sum: Int.(Int) -> Int = { other -> plus(other) }

匿名函数语法允许直接指定函数字面值的接收者类型。 如果需要使用带接收者的函数类型声明一个变量，并在之后使用它，这将非常有用

val sum = fun Int.(other: Int): Int = this + other

当接收者类型可以从上下文推断时， lambda 表达式 可以用作带接收者的函数字面值：

class HTML {
    fun body() { /*……*/ }
}

fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()  // 创建接收者对象
    html.init()        // 将该接收者对象传给该 lambda
    return html
}

html {       // 带接收者的 lambda 由此开始
    body()   // 调用该接收者对象的一个方法
}