高階函數（Higher-Order Functions）
接受函數作為參數的函數，或返回值類型是函數類型的函數成為高階函數。這個概念的很好的一個例子是lock()函數，這個函數接收一個Lock類型的參數（鎖對象），和一個函數類型的參數：獲取鎖，運行函數參數，然后釋放鎖：
fun <T> lock(lock: Lock, body: () -> T): T {
lock.lock()
try {
return body()
}
finally {
lock.unlock()
}
}
分析上面的代碼：body形參的類型是函數類型：() -> T，因此該形參的實參是一個無參，返回值類型是T的函數。該函數參數在try塊中被調用，被lock保護，且其結果被lock（）返回。
如果我們想要調用上述lock（）函數，我們可以傳入已經定義好的函數作為lock（）函數的參數，如：
fun toBeSynchronized() = sharedResource.operation()
val result = lock(lock, ::toBeSynchronized)
除此之外，一個更簡潔的方法是傳入一個λ表達式：
val result = lock(lock, { sharedResource.operation() })
λ表達式將在下文詳細介紹，但是為了更好的理解現在講解的內容，不妨先來概述以下λ表達式的知識：
- λ表達式總是被大括號包裹
- 若存在參數，則參數在
->之前聲明，（參數類型可以省略） - 若存在函數體，則函數體在
->之后聲明
在Kotlin中，有一個常見用法：如果一個函數的最后一個參數是函數類型，且傳入的實參時λ表達式，則可以在圓括號之外給出這個λ表達式：
lock (lock) {
sharedResource.operation()
}
高階函數的另一個形象的例子是map()函數：
fun <T, R> List<T>.map(transform: (T) -> R): List<R> {
val result = arrayListOf<R>()
for (item in this)
result.add(transform(item))
return result
}
該函數可以如下調用：
val doubled = ints.map { value -> value * 2 }
注意：若λ表達式是目標函數的唯一參數，則調用目標函數時，圓括號可以省略。
it：單參數的隱式表達（it: implicit name of a single parameter）
另一個有用的約定是如果一個字面函數只有一個參數，則該參數的聲明連同符號->都可以省略，以it代指該參數：
ints.map { it * 2 }
這些約定可以寫LINQ-style風格的代碼：
strings.filter { it.length == 5 }.sortBy { it }.map { it.toUpperCase() }
未使用變量的下劃線代替法（Underscore for unused variables (since 1.1))
若λ表達式的參數沒有使用，則可以使用下劃線代替沒有使用的參數名：
map.forEach { _, value -> println("$value!") }
λ表達式的解構（Destructuring in Lambdas (since 1.1))
λ表達式表達式的解構在解構聲明（暫未學到）章節中講解。
內聯函數（Inline Functions）
使用內聯函數有時候能提高高階函數的性能。
λ表達式和匿名方法（Lambda Expressions and Anonymous Functions）
一個λ表達式或一個匿名函數都是一個函數字面值，也就是一個函數未聲明，但立即作為表達式傳遞：
max(strings, { a, b -> a.length < b.length })
函數max是一個高階函數，因為它的第二個參數接收一個函數類型的參數。第二個參數是一個表達式，該表達式本身就是一個函數，也就是函數字面值。作為一個函數，它等同于：
fun compare(a: String, b: String): Boolean = a.length < b.length
函數類型（Function Types）
若一個函數的參數是函數類型，我們必須為該參數指定類型。例如上述函數max定義如下：
fun <T> max(collection: Collection<T>, less: (T, T) -> Boolean): T? {
var max: T? = null
for (it in collection)
if (max == null || less(max, it))
max = it
return max
}
參數less的類型是(T, T) -> Boolean，一個接收兩個T類型參數，且返回Boolean類型的函數：如果第一個參數小于第二個參數的時候返回true。
在代碼第四行，less被用作函數：通過傳入兩個T類型的參數被調用。
一個函數類型如上所寫，當然也可以指定參數名稱。如果想知名每一個參數含義的話：
val compare: (x: T, y: T) -> Int = ...
λ表達式表達式語法（Lambda Expression Syntax）
λ表達式表達式的完整語法，也就是函數類型變量的字面值如下：
val sum = { x: Int, y: Int -> x + y }
λ表達式總是被花括號包裹，完整語法的參數放置在圓括號內，參數可以有注解，方法體在->符號的右邊。如果推斷出λ表達式的返回類型不是Unit，則最后一個表達式將作為返回值。
如果我們補全所有可選標注，看起來如下：
val sum: (Int, Int) -> Int = { x, y -> x + y }
只有一個參數的λ表達式是非常常見的。如果Kotlin可以確定出λ表達式的簽名，我們可以省略哪個唯一的參數，且將隱式為我們聲明一個名為it的參數：
ints.filter { it > 0 } // this literal is of type '(it: Int) -> Boolean'
我們可以使用特定的return語法從λ表達式顯式返回一個值。否則，最后一個表達式的值將隱式返回。因此，下面兩段代碼是等價的：
ints.filter {
val shouldFilter = it > 0
shouldFilter
}
ints.filter {
val shouldFilter = it > 0
return@filter shouldFilter
}
注意：如果一個函數的最后一個參數是函數類型，該參數可以在參數列表之外傳遞。
匿名函數（Anonymous Functions）
λ表達式語法缺少指定函數返回類型的能力。在大多數情況下，這不是必要的，因為返回類型可以自動的推斷出來。然而，如果需要顯式指定返回類型，可以使用另一個語法：匿名函數。
fun(x: Int, y: Int): Int = x + y
匿名函數看起來非常像常規函數的聲明，除了沒有函數名。匿名函數的函數體可以是表達式也可以是代碼塊：
fun(x: Int, y: Int): Int {
return x + y
}
參數可返回值的指定與常規函數一樣，但參數類型可以推斷出來的時候，參數類型是可以省略的：
ints.filter(fun(item) = item > 0)
匿名函數的返回類型工作機制就像常規函數一樣：對于函數體是表達式的，可以自動推斷；對于函數體是代碼塊的，則必須顯式指定（除了Unit）。
注意：實參時匿名函數的參數總是傳遞到括號內。將函數留在圓括號外的簡介語法僅僅適用于λ表達式。
λ表達式和匿名函數的另一個不同是非局部返回的行為。沒有標簽的return語句總是返回至使用fun關鍵字的函數聲明處。這意味著λ表達式內部的return將返回至包含它的封閉函數出；而匿名函數的return將返回至匿名函數本身。
閉包（Closures）
λ表達式或匿名函數（無論是作為局部函數還是對象表達式）都可以訪問其閉包，即在外部作用于中聲明的變量。不同于Java，閉包中的變量可以被修改：
var sum = 0
ints.filter { it > 0 }.forEach {
sum += it
}
print(sum)
帶接收者的函數字面值（Function Literals with Receiver）
Kotlin可以為函數字面值提供接收者對象。在函數字面值的函數體內部，可以無需任何額外的修飾符就調用接收者對象的方法。這與擴展函數是類似的，允許在函數體內部訪問接收者對象的成員。其用法的主要例子是類型安全的Groovy-風格構建起。
這樣的函數字面的類型是帶有接收器的函數類型：
sum : Int.(other: Int) -> Int
上述函數字面可以像接收者對象自身的函數一樣調用：
1.sum(2)
匿名函數語法允許直接指定函數字面的接收者類型。如果需要為函數聲明一個變量，并使用它，這將非常有用：
val sum = fun Int.(other: Int): Int = this + other
當接收者類型可以從上下文推斷出來的話，λ表達式可以用作帶有接收者的函數字面值：
class HTML {
fun body() { ... }
}
fun html(init: HTML.() -> Unit): HTML {
val html = HTML() // create the receiver object
html.init() // pass the receiver object to the lambda
return html
}
html { // lambda with receiver begins here
body() // calling a method on the receiver object
}