Kotlin 函数都是头等的，这意味着它们可以存储在变量与数据结构中、作为参数传递给其他高阶函数以及从其 他高阶函数返回。可以像操作任何其他非函数值⼀样操作函数。

一、高阶函数

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

二、函数类型

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

1.函数类型实例化

• 使用函数字面值的代码块，采用以下形式之⼀：
  1. lambda 表达式: { a, b -> a + b }
  2. 匿名函数: fun(s: String): Int { return s.toIntOrNull() ?: 0 }
• 使用已有声明的可调用引用：
  1. 顶层、局部、成员、扩展函数：::isOdd 、String::toInt
  2. 顶层、成员、扩展属性：List<Int>::size
  3. 构造函数：::Regex
• 使⽤实现函数类型接⼝的⾃定义类的实例：

class IntTransformer : (Int) -> Int {
    override operator fun invoke(x: Int): Int = TODO()
}

val intFunction: (Int) -> Int = IntTransformer()

带与不带接收者的函数类型非字面值可以互换，其中接收者可以替代第⼀个参数，反之亦然。例如，(A, B) -> C 类型的值可以传给或赋值给期待 A.(B) -> C 的地方，反之亦然

val repeatFun: String.(Int) -> String = { times -> this.repeat(times) }
val twoParameters: (String, Int) -> String = repeatFun
fun runTransformation(f: (String, Int) -> String): String {
    return f("hello", 3)
}

val result = runTransformation(repeatFun)

2.函数类型实例调用

函数类型的值可以通过其 invoke(……) 操作符调用：f.invoke(x) 或者直接 f(x) 。
如果该值具有接收者类型，那么应该将接收者对象作为第⼀个参数传递。调用带有接收者的函数类型值的另⼀个方式是在其前面加上接收者对象，就好比该值是⼀个扩展函数：1.foo(2)

val stringPlus: (String, String) -> String = String::plus
val intPlus: Int.(Int) -> Int = Int::plus
println (stringPlus.invoke("<-", "->"))
println (stringPlus("Hello, ","world!"))
println (intPlus.invoke(1, 1))
println (intPlus(1, 2))
println (2.intPlus(3)) // 类扩展调⽤

3.内联函数

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

三、Lambda表达式和匿名函数

lambda 表达式与匿名函数是“函数字面值”，即未声明的函数

1.Lambda 表达式语法

lambda 表达式总是括在花括号中，完整语法形式的参数声明放在花括号内，并有可选的类型标注，函数体跟在 ⼀个 -> 符号之后。如果推断出的该 lambda 的返回类型不是 Unit，那么该 lambda 主体中的最后⼀个（或 可能是单个）表达式会视为返回值。

val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }
val sum = { x: Int, y: Int -> x + y }//可选标注都留下

2.传递末尾的 lambda 表达式

在 Kotlin 中有⼀个约定：如果函数的最后⼀个参数是函数，那么作为相应参数传入的 lambda 表达式可以放在圆括号之外,这种语法也称为拖尾 lambda 表达式。

val product = items.fold(1) { acc, e -> acc * e }

如果该 lambda 表达式是调用时唯⼀的参数，那么圆括号可以完全省略：

run { println("...") }

3.it：单个参数的隐式名称

如果编译器自己可以识别出签名，也可以不用声明唯⼀的参数并忽略 -> 。该参数会隐式声明为 it:

ints.filter { it > 0 } // 这个字⾯值是“(it: Int) -> Boolean”类型的

4.从 lambda 表达式中返回⼀个值

使用返回标签语法从 lambda 显式返回⼀个值。否则，将隐式返回最后⼀个表达式的值。

ints.filter {
    val shouldFilter = it > 0
    shouldFilter
}
ints.filter {
    val shouldFilter = it > 0
    return@filter shouldFilter
}

搭配圆括号可外传递函数类型参数lambda表达式,可支持链式编程（LINQ）语法:

strings.filter { it.length == 5 }.sortedBy { it }.map { it.toUpperCase() }

5.下划线用于未使用的变量

如果 lambda 表达式的参数未使用，那么可以用下划线取代其名称：

map.forEach { _, value -> println("$value!") }

6.在 lambda 表达式中解构

你可以对 lambda 表达式参数使⽤解构声明语法。如果 lambda 表达式具有 Pair 类型（或者 Map.Entry 或任何其他具有相应 componentN 函数的类型）的参数，那么可以通过将它们放在括号中来引⼊多个新参数 来取代单个新参数：

map.mapValues { entry -> "${entry.value}!" } 
map.mapValues { (key, value) -> "$value!" }

7.匿名函数

需要显示指定函数返回类型可以使用匿名函数。看起来非常像⼀个常规函数声明，除了其名称省略了。其函数体可以是表达式或代码块：

//表达式
fun(x: Int, y: Int): Int = x + y
//代码块
fun(x: Int, y: Int): Int { 
    return x + y 
}

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

匿名函数和Lambda的区别：

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

8.闭包

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

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

9.带有接收者的函数字面值

带有接收者的函数类型，例如 A.(B) -> C ，可以用特殊形式的函数字面值实例化—— 带有接收者的函数字面值。
在这样的函数字⾯值内部，传给调⽤的接收者对象成为隐式的this，以便访问接收者对象的成员而无需任何额外的限定符，亦可使用 this 表达式 访问接收者对象。

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

匿名函数语法允许你直接指定函数字⾯值的接收者类型

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