Kotlin文法 - 関数とラムダ


# はじめに

[Kotlin文法 - ネストされたクラス、Enumクラス、オブジェクト、委譲、委譲されたプロパティ](http://qiita.com/k5n/items/57d362295c2299090d8d)の続き。

[Kotlin Reference](https://kotlinlang.org/dscs/reference/)のFunctions and Lambdas章の大雑把日本語訳。適宜説明を変えたり端折ったり補足したりしている。

# 関数

*fun* キーワードを使って宣言する。

```kotlin
fun double(x: Int): Int {
}
```

## 関数の利用

```kotlin
val result = double(2)
```

メンバ関数（メソッド）の場合は

```kotlin
Sample().foo() // Sampleクラスのインスタンスを作ってfooを呼び出す
```

### 接中辞(infix)記法

次の場合に接中辞記法を使うことができる。

 - メンバ関数か拡張関数
 - 引数が１つだけ
 - 関数に *infix* キーワードが付けられている

```kotlin
//infixを付けてIntに拡張関数を追加
infix fun Int.shl(x: Int): Int {
...
}

//接中辞記法を使って拡張を呼び出す
1 shl 2
// 上は下と同じ
1.shl(2)
```

### パラメータ

関数のパラメータはPascal記法、つまり *名前: 型* を用いて定義する。パラメータはコンマで区切られている。全てのパラメータは型を明示しなければならない。

```kotlin
fun powerOf(number: Int, exponent: Int) {
...
}
```

## デフォルト引数

関数の引数はデフォルト値を持てる。これによってオーバーロードの数を減らすことができる。

```kotlin
// offのデフォルト値は0, lenのデフォルト値はb.size()
fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size()) {
...
}
```

## 名前付き引数

関数を呼び出すときに引数名を指定できる。これはデフォルト値を持つパラメータが沢山あるときに便利。

```kotlin
fun reformat(str: String,
             normalizeCase: Boolean = true,
             upperCaseFirstLetter: Boolean = true,
             divideByCamelHumps: Boolean = false,
             wordSeparator: Char = ' ') {
...
}

// デフォルト値を使って呼ぶ
reformat(str)

// デフォルト値を使わないで呼ぶ
reformat(str, true, true, false, '_')

// 引数名を指定して呼ぶ
reformat(str,
    normalizeCase = true,
    upperCaseFirstLetter = true,
    divideByCamelHumps = false,
    wordSeparator = '_'
  )

// wordSeparatorだけデフォルト値を使わずに呼ぶ
reformat(str, wordSeparator = '_')
```

ただしJava関数を呼ぶときは名前付き引数は使えない。Javaのバイトコードは引数名を保存していないので。

## Unitを返す関数

関数が有用なものを返さないなら戻り値は *Unit* 型になる。*Unit* はただ１つの値 *Unit* を持つ型。この型は明示的に返す必要はない。

```kotlin
fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` または `return` と書くのはオプション。書かなくてもいい。
}
```

関数宣言で戻り値に *Unit* と書くのは省略できる。上の関数宣言はこう書いても一緒。

```kotlin
fun printHello(name: String?) {
    ...
}
```

## 式が１つの関数

関数の中身が式１つだけなら、波括弧は省略できる。

```kotlin
fun double(x: Int): Int = x * 2
```

戻り値の型が推論可能ならそれも省略できる。

```kotlin
fun double(x: Int) = x * 2
```

## 明示的な戻り値型

ブロックを持つ関数は型が *Unit* でない限り、戻り値型を明示する必要がある。なぜならブロックを持つ関数は複雑な制御フローを持つかもしれず、戻り値型は読み手にとって（ときにはコンパイラにさえも）明らかでないから。

## 可変長引数(Varargs)

関数のパラメータ（普通は最後の１つ）には *vararg* 修飾子が付けられているかもしれない。

```kotlin
fun <T> asList(vararg ts: T): List<T> {
  val result = ArrayList<T>()
  for (t in ts) // ts は Array である
    result.add(t)
  return result
}
```

こうすると関数に渡す引数の数を可変にできる。

```kotlin
  val list = asList(1, 2, 3)
```

関数の中では T 型の引数 ts は T の配列に見える。すなわち上の例で ts の型は *Array&lt;out T&gt;* である。

パラメータのうち１つだけが *vararg* を付けられる。もしそれが最後の引数でなかったら、後続の引数は名前付き引数を使って渡すか、または後続の引数が関数型なら括弧の外からラムダを渡す。

```kotlin
// varargが付いてるのが最後の引数でない場合
fun testMiddleVararg(vararg ts: Int, lastArg: String) {
  // ...
}

// varargより後の引数は名前付きで渡す必要がある
testMiddleVararg(1, 2, 3, lastArg = "test")

// varargが付いてるのが最後の引数でなく、残りの引数が関数型の場合
fun testVarargWithFunc(vararg ts: Int, proc: () -> Unit) {
  // ...
}

// 引数を渡す括弧の外でラムダを渡すなら、それが最後の引数だと分かる
testVarargWithFunc(1, 2, 3) {
  // 最後の引数に渡す処理
}
```

既に渡したいものを配列として持ってるなら、配列の前にアスタリスクを付けることで展開して渡せる。

```kotlin
val a = arrayOf(1, 2, 3)        // 可変長引数に渡したいものを配列にする
val list = asList(-1, 0, *a, 4) // *をつけて展開して渡す
```

## 関数のスコープ

Kotlinでは関数はファイルのトップレベルで宣言できる。つまりJava, C#, Scalaのように関数を入れるためのクラスを用意する必要はない。トップレベルの関数に加えて、（関数内で）ローカルに、メンバ関数として、拡張関数として宣言することもできる。

メンバ関数や拡張関数はもう説明しているからいいよね？ローカル関数だけ説明するよ。

### ローカル関数

関数の中で関数を宣言できる。

```kotlin
fun dfs(graph: Graph) {
  // この関数はこのブロックの中でしか使わないから、ローカルとして宣言しとこ
  fun dfs(current: Vertex, visited: Set<Vertex>) {
    if (!visited.add(current)) return
    for (v in current.neighbors)
      dfs(v, visited)
  }

  dfs(graph.vertices[0], HashSet())
}
```

ローカル関数はその外側の変数にアクセスできる。なので上の例で visited はローカル変数にできる。

```kotlin
fun dfs(graph: Graph) {
  val visited = HashSet<Vertex>()
  fun dfs(current: Vertex) {
    // この関数の中で、外側にあるvisitedが見える。
    if (!visited.add(current)) return
    for (v in current.neighbors)
      dfs(v)
  }

  dfs(graph.vertices[0])
}
```

ローカル関数はラベルを指定することで外側の関数を抜けることもできる。

```kotlin
fun reachable(from: Vertex, to: Vertex): Boolean {
  val visited = HashSet<Vertex>()
  fun dfs(current: Vertex) {
    // ここのreturnは外側の関数(reachable)を抜ける
    if (current == to) return@reachable true
    
    // ここのreturnはこのローカル関数(dfs)を抜ける
    if (!visited.add(current)) return
    
    for (v in current.neighbors)
      dfs(v)
  }

  dfs(from)
  return false // もしdfs()が既にreturn trueで抜けていなかったら
}
```

## 末尾再帰

Kotlinは__末尾再帰(tail recursion)__として知られる関数型プログラミングのスタイルをサポートしている。これは通常はループで書くアルゴリズムを、スタックオーバーフローを起こすリスクなく再帰を使って書けるようにしてくれる。要求される形を満たした上で関数の頭に *tailrec* 修飾子を付けると、コンパイラが再帰を（高速で効率的な）ループに置き換えて最適化する。

```kotlin
tailrec fun findFixPoint(x: Double = 1.0): Double
        = if (x == Math.cos(x)) x else findFixPoint(Math.cos(x))
```

これは数学の定数であるコサインの不動点を計算するコード。単純に1.0から始めてMath.cos()を結果がもう変化しなくなるまで繰り返し呼び出す。つまり0.7390851332151607が導き出されるまで。コンパイラが吐き出すコードは伝統的なスタイルの以下と同等のものになる。

```kotlin
private fun findFixPoint(): Double {
    var x = 1.0
    while (true) {
        val y = Math.cos(x)
        if (x == y) return y
        x = y
    }
}
```

*tailrec* に適合させるために、関数は最後の処理として自分自身を呼び出さなければならない。再帰呼び出しの後にまだコードがある場合、末尾再帰は使えない。またtry/catch/finallyブロックの中でも使えない。今の所、末尾再帰はJVMバックエンドでのみサポートされている。

# 高階関数とラムダ

## 高階関数

高階関数はパラメータとして関数を取ったり、関数を返したりする関数のこと。ロックオブジェクトを受け取って関数を実行する *lock()* が良い例。これはロックを獲得してから関数を実行して、ロックを解除する。

```kotlin
// body は () -> T の関数型で、引数なしで T 型の戻り値を返す関数を表している。
fun <T> lock(lock: Lock, body: () -> T): T {
  lock.lock()  // 処理を実行する前にロックする
  try {
    return body()  // 渡された関数を実行
  }
  finally {
    lock.unlock()  // ロックを解除する（実行に成功しようが失敗しようが）
  }
}
```

これを呼び出すには引数として別の関数を渡す。

```kotlin
// toBeSynchronized()関数を宣言
fun toBeSynchronized() = sharedResource.operation()

// このtoBeSynchronized()関数を渡したいのだが、それには::で参照を取得する
val result = lock(lock, ::toBeSynchronized)
```

もっと簡便な方法はラムダを渡すこと。ラムダの書式については後で説明する。

```kotlin
val result = lock(lock, { sharedResource.operation() })
```

最後の引数が関数なら、引数を並べる( )括弧の外に出すのがKotlinの慣習。

```kotlin
lock (lock) {
  sharedResource.operation()
}
```

他の高階関数の例として *map()* がある。

```kotlin
// List内の各要素を、渡された関数を使って別のものに置き換えたListを返す
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
}
```

この関数は次のように呼び出せる。

```kotlin
// intsの各要素がitとして渡されるので、それを2倍にした要素に置き換えたリストを作成する
val doubled = ints.map { it -> it * 2 }
```

ラムダに渡される引数が１つだけなら、その名前はデフォルトで *it* なので省略できる。

```kotlin
ints.map { it * 2 }
```

これらの慣習を使うとC#のLINQスタイル[^1]のコードが書ける。

[^1]: これLINQスタイルっていうのかな？LINQってSQLっぽく書くやつだと思ってたけど。まぁ関数名がSQLぽいってだけで概念は一緒だけど。見た目はものすっごいRubyっぽいって思う。

```kotlin
// stringsの要素のうち、長さが5のものだけ取り出して、それを要素自体で比較して並び替えて、
// 中身を大文字に変換したものを生成する
strings.filter { it.length == 5 }.sortBy { it }.map { it.toUpperCase() }
```

## ラムダ式と無名関数

ラムダ式または無名関数は「関数リテラル」である。つまり関数は宣言されていないけど即座に式として渡せる。次の例を考えてみよう。

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

関数 *max* は高階関数、つまり２つ目の引数として関数を取る。２つ目の引数として渡しているものは式でありそれ自身が関数−つまり関数リテラルである。関数として等価なのは以下になる。

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

### 関数型

引数として他の関数をとるためには、その関数の型を指定しないといけない。例えば上で出てきた *max* は以下のように定義される。

```kotlin
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))  // ここでlessを呼び出している
      max = it
  return max
}
```

パラメータ *less* の型は *(T, T) -> Boolean* で、これは型が T の２つの引数を取り、戻り値が Boolean の関数を表す。４行目でこの *less* を型 T の２つの引数を渡して呼び出している。

### ラムダ式の書式

ラムダ式の完全な書式は以下になる。

```kotlin
val sum = { x: Int, y: Int -> x + y }
```

ラムダ式は波括弧で括られ、波括弧の中にあるその引数の型はオプション。関数の中身は -&gt; の後に続く。引数の型を外に出すと次のようになる。

```kotlin
val sum: (Int, Int) -> Int = { x, y -> x + y }
```

### 無名関数

ラムダ式の書式で１つ抜け落ちているのは戻り値の型。大抵は自動的に推論できるからいらないんだけど、もし明示的に指定する必要があれば *無名関数* が使える。

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

名前がない以外は普通の関数と見た目は一緒。中身は式でもブロックでもいい。

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

パラメータや戻り値の型は文脈から推論できるなら省略できる。戻り値の型の省略に関しては普通の関数とルールは同じ。

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

ラムダ式と違って無名関数は引数を並べる ( ) 括弧の外には出せない。

もう一つの重要なラムダ式との違いは、内部で *return* したときの動作。これは[以前も説明](http://qiita.com/k5n/items/acfaff8b56faf57971f7#return%E3%81%A8%E3%83%A9%E3%83%99%E3%83%AB)した。ラベルを付けずに *return* した場合、ラムダは外側の関数を抜けるが、無名関数はその無名関数自身を抜ける。

### クロージャ

（ローカル関数やオブジェクト式と同様に）ラムダ式や無名関数はその外側で宣言された変数にアクセスできる。Javaと違ってクロージャにキャプチャした変数を変更できる。

```kotlin
var sum = 0
ints.filter { it > 0 }.forEach {
  sum += it  // このラムダ式はブロックの外側にあるsumにアクセスして、しかも変更している
}
print(sum)
```

### レシーバ付きの関数リテラル

Kotlinはレシーバ（そのメソッドを呼び出されるオブジェクト）を指定して関数リテラルを呼び出す方法を提供している。関数リテラルのボディの中で、そのオブジェクトのメソッドを呼び出すことができる。これは拡張関数に似ている[^2]。この機能の最も重要な利用例は[型安全なGoovyスタイルのビルダー](https://kotlinlang.org/docs/reference/type-safe-builders.html)である。

[^2]: 拡張関数もボディ内でレシーバオブジェクトのメソッドを呼び出せる

レシーバ付きの関数リテラルの型は次のようになる。

```kotlin
// レシーバはInt型で、引数はother: Int、戻り値はInt型
sum : Int.(other: Int) -> Int
```

これはまるでレシーバオブジェクトのメソッドであるかのように呼び出せる。

```kotlin
// 1をレシーバにして、レシーバ付き関数リテラル sum を呼び出す
1.sum(2)
```

無名関数の書式なら関数リテラルの型を直接指定できる。これはレシーバ付き関数型の変数を宣言して、後でそれを使う場合に便利。

```kotlin
// レシーバはInt型で、引数はother:Int、戻り値はInt型のレシーバ付き無名関数をsumに代入
val sum = fun Int.(other: Int): Int = this + other  // 自身と引数otherを足した値を返す
```

レシーバ付きラムダ式は文脈からレシーバの型が推論できる場合に使える[^3]。

[^3]: この例はDSL(Domain Specific Language)がこんな感じで作れるよって言いたいみたいね。

```kotlin
class HTML {
    fun body() { ... }
}

// init引数はレシーバがHTML型で、引数なし、戻り値なし(Unit)
fun html(init: HTML.() -> Unit): HTML {
  val html = HTML()  // レシーバオブジェクトを作る
  html.init()        // ラムダにレシーバオブジェクトを渡す
  return html
}

// html関数にレシーバ付きラムダを渡す
html {       // レシーバ付きラムダ開始
    body()   // レシーバオブジェクトのメソッドを呼び出す。this.body()
}
```

# インライン関数

高階関数を使うことは幾らかの実行時のペナルティがあることを暗示している。これらの関数はオブジェクトであり、関数ボディからアクセスできるように外部環境をキャプチャする。メモリ確保と仮想関数呼び出し[^4]は実行時のオーバーヘッドとなる。

[^4]: 実行時にメモリからアドレスを取得して関数を呼び出すこと。

多くの場合この種のオーバーヘッドはラムダ式をインラインにすることで除去できる。上で挙げた *lock()* 関数はその良い例で、簡単に呼び出し側でインライン展開できる。次の場合を考えてみよう。

```kotlin
lock(l) { foo() }
```

*lock()* に渡す関数オブジェクトを生成してそれを呼び出すコードを生成する代わりに、コンパイラが次のコードを吐き出してくれたなぁ。

```kotlin
l.lock()
try {
  foo()
}
finally {
  l.unlock()
}
```

手始めに欲しいのはこんなのじゃない？

これをコンパイラにやらせるために、*lock()* 関数の前に *inline* 修飾子を付ける必要がある。

```kotlin
inline fun lock<T>(lock: Lock, body: () -> T): T {
  // ...
}
```

インラインは生成されるコードの肥大化を招く。しかし妥当なやり方（つまりデカい関数をインラインにしない）をすれば、パフォーマンス上の効果を生む[^5]。

[^5]:  「特にループ内でメガモーフィック(megamorphic)なコールサイトにあるときに」という記述があったが難しい話なので削除。ようするにインライン化されていないと呼び出しにコストがかかるので、ループ内で何度も呼び出されるような状況なら高速化のためにキャシュする。つまり２回目からはオーバーヘッドがかからない。でもそういうのが多すぎてもうキャッシュできないよ〜って状態にある場合のこと。

## noinline

インライン関数の引数にラムダを渡す時、引数に *noinline* 修飾子を付けることができる。

```kotlin
inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) {
  // ...
}
```

インライン化できるラムダは関数の中で呼び出すか、インライン化できる引数として渡すことしかできない。*noinline* が付けられたものは何とでも好きなように操作することができる。つまりフィールドに格納したり、持ち回したり。

注：もしインライン関数がインライン可能な関数パラメータも持たず、具象化型パラメータ（後述）も持たないなら、コンパイラは警告を発する。それらの関数をインライン化することにメリットがあるとは思えないので（もしインライン化が必要だとはっきりしているなら、警告を抑制できる）。

## ローカルでないreturn

前にも書いたけど、Kotlinではラベルなしの *return* は（無名含む）関数を抜けるけど、ラムダを抜けるにはラベルが必要。

```kotlin
fun foo() {
  ordinaryFunction {
     return // ERROR: ここではfooを抜けるreturnは作れない
  }
}
```

でもラムダがインラインとして渡されているなら、*return* はインライン展開されるのでこう書いてもいい。

```kotlin
fun foo() {
  inlineFunction {  // このラムダがインラインなら
    // このreturnはこのラムダではなくfooを抜ける
    return // OK: ラムダはインライン展開されて、returnの意味もfoo内に直接書いたのと同じになる。
  }
}
```

このような *return* （ラムダ内にあって、でも外側の関数を抜ける）を *ローカルでないreturn* と呼んでいる。インライン関数を使うループの中でこんな感じに利用するのに向いてる。

```kotlin
fun hasZeros(ints: List<Int>): Boolean {
  ints.forEach {
    if (it == 0) return true // hasZerosを抜ける
  }
  return false
}
```

インライン関数は渡されたラムダを関数ボディ内から直接呼び出すだけでなく、他の実行文脈から呼び出すこともある。ローカルオブジェクトやネストされた関数のような。そういう場合、ローカルでないフロー制御は許可されない。それを示すために、ラムダ引数に *crossinline* 修飾子を付ける必要がある。

```kotlin
// crossinlineを付けたので、bodyに渡すラムダはローカルなフロー制御を使ってはいけない。
// この関数の呼び出し元でそのようなラムダを渡すとコンパイルエラーになる。
inline fun f(crossinline body: () -> Unit) {
    val f = object: Runnable {
        // 渡されたbodyは関数fのボディ内でなく、ローカルオブジェクトから呼び出される
        override fun run() = body()
    }
    // ...
}
```

*break* や *continue* はまだインラインのラムダ内で利用できないけど、将来サポートしようとは思ってる。

## 具象化型パラメータ

しばしばパラメータとして渡された型にアクセスする必要がある。

```kotlin
fun <T> TreeNode.findParentOfType(clazz: Class<T>): T? {
    var p = parent
    while (p != null && !clazz.isInstance(p)) {
        p = p.parent
    }
    @Suppress("UNCHECKED_CAST")
    return p as T
}
```

ここではリフレクションを使ってノードがある型かどうかをチェックしている。うまく動くけど、呼び出す側は綺麗に書けない。

```kotlin
myTree.findParentOfType(MyTreeNodeType::class.java)
```

実際にやりたいことは、単にこの関数に型を渡したいだけ。こんな風に。

```kotlin
myTree.findParentOfType<MyTreeNodeType>()
```

これをできるようにするため、インライン関数は *具象化型パラメータ* をサポートする。なのでこんな感じに書ける。

```kotlin
inline fun <reified T> TreeNode.findParentOfType(): T? {
    var p = parent
    while (p != null && p !is T) {
        p = p?.parent
    }
    return p as T
}
```

型パラメータに *refied* 修飾子を付けると、関数内でまるで普通のクラスであるかのようにアクセスできるようになる。関数はインライン展開されるので、リフレクションを使わずとも、 *!is* とか *as* とかが使える[^6]。

[^6]: reified付けなくてもasは使えてるけど・・・

多くの場合リフレクションは必要にならないけど、具象化型パラメータに対しても使うことはできる。

```kotlin
inline fun <reified T> membersOf() = T::class.members

fun main(s: Array<String>) {
  println(membersOf<StringBuilder>().joinToString("\n"))
}
```

（*inline* を付けられていない）普通の関数は具象化型パラメータを持てない。実行時表現を持たない型（つまり具象化可能でない型[^7]や *Nothing* のような架空の型）は具象化型パラメータとしては使えない。

[^7]: 型消去が行われる型。型消去はJava5より前の型とのバイトコード互換性のために行われる処理。

# 次の章へ

次は[Kotlin文法 - 分解宣言、範囲、型チェックとキャスト](http://qiita.com/k5n/items/c8bf7a507b64f20eebd0)へGO!