Kotlinのスコープ関数の定義を読み解く

【移行のお知らせ】[プライバシー上の懸念](https://blog.qiita.com/about-user-page-renewal-20200326/)により、Qiitaアカウントの削除を検討しています。
各投稿は個人blog( https://gateau.hatenablog.com/archive/category/Qiita )に移行しました。
今後も参照される方は、ブックマークなど移行をお願い致します。

---

Kotlinのスコープ関数はlet, with, run, apply, alsoがあります。
`public inline fun <T, R> T.let(block: (T) -> R): R = block(this)`などの[それぞれの定義](https://github.com/JetBrains/kotlin/blob/master/libraries/stdlib/src/kotlin/util/Standard.kt)を読んでもすぐ頭に入ってこないので、読み方を解説してみます。自分用チートシートです。

## 前提知識

#### 拡張関数
- クラスを継承したりDecoratorのようなデザインパターンを使用せずとも、クラスを新しい機能で拡張できる言語機能
- 公式 https://dogwood008.github.io/kotlin-web-site-ja/docs/reference/extensions.html
- Kotlin イン・アクション P.68

#### 高階関数
- 引数として関数を取るか、関数を返り値とする関数
- 公式 https://dogwood008.github.io/kotlin-web-site-ja/docs/reference/lambdas.html
- Kotlin イン・アクション P.264〜

#### インライン関数
- inline修飾子をつけると、関数呼び出しを生成せず、実装する実際のコードに置換する機能（スコープ関数の定義に使われているが、使うときには特に意識しなくても良い）
- 公式 https://dogwood008.github.io/kotlin-web-site-ja/docs/reference/inline-functions.html
- Kotlin イン・アクション P.277

#### ジェネリクス
- 型パラメータ（Kotlinではよく `<T>` のように表される）を持った型を定義できる仕組み
- 公式 https://dogwood008.github.io/kotlin-web-site-ja/docs/reference/generics.html
- Kotlin イン・アクション P.294

## let
#### 定義
```kotlin
public inline fun <T, R> T.let(block: (T) -> R): R = block(this)
```
![let.png](https://qiita-image-store.s3.amazonaws.com/0/36199/6d9085da-e93f-10de-a0e2-e69d78c88182.png)
> Calls the specified function [block] with `this` value as its argument and returns its result.

- 自分自身Tを引数としてblock関数を実行し、その結果を返します。
- Kotlin イン・アクション P.189

#### 使用例
```kotlin
fun sendEmail(email: String): Boolean { /* ... */ }
val result = email?.let { sendEmail(it) } // it = email
```
安全呼び出し演算子と使えば、emailがnullでないときだけ、emailを引数にとってsendEmailを実行する、といった処理を完結に書けます。letを使わない場合はこのようにnullチェックが必要になり冗長です。

```kotlin
var result = false
if (email != null) { result = sendEmail(email) } 
```

#### 英語としてわかりやすい例
- 英語の文法的には、「let + <目的語> + <動詞>」となり、「<目的語>に<動詞>をさせる」という意味です。

```kotlin
val s = "hoge".let { it.toUpperCase() } // s = "HOGE"
```
ただこの例だと後述のrunを使った方が `"hoge".run { toUpperCase() }` とスッキリします。対象オブジェクトを引数にしたいときに使う方が良さそうです。

#### 使い時
- `if (hoge != null) ...`のような記述をしたくなったとき（これが圧倒的に多い）
- 対象オブジェクトを引数にして、まとめて処理を行いたいとき
- thisを変えたくないとき（関数内でcontextを使った処理があるなど。this@MainActivityのような指定も可能ではある）

```kotlin
// Activity内で
val s = "hoge".let {
    Toast.makeText(this, it, Toast.LENGTH_LONG).show();
    it.toUpperCase()
}
```

## with

#### 定義
```kotlin
public inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
```
![with.png](https://qiita-image-store.s3.amazonaws.com/0/36199/212ab275-2ad0-4210-3ac6-ab3684d876ee.png)

> Calls the specified function [block] with the given [receiver] as its receiver and returns its result.

- 第一引数に任意の型Tを取り、そのTをレシーバとして第二引数を実行します。
- 同じオブジェクトに対してその名前を繰り返すことなく複数の操作を出来る関数です。
- Kotlin イン・アクション P.169

#### 使用例
```kotlin
val numbers = with(StringBuilder()) {
    append("Numbers: ")
    for (i in 1..3) append(i)
    toString()                  // 全ての行でthisを省略出来て読みやすい
}
println(numbers) // Numbers: 123
```

#### 英語としてわかりやすい例
- withは前置詞で、後ろに名詞（句・節）か動名詞が来ます。引数として渡すので名詞が良いでしょう。〜とともに、〜を使って、などの意味があります。

```kotlin
val love = with(you){ date(me) }

// letを使って同じ処理を書く場合
val love = you.let { it.date(me) } 
```
letを使っても同じ書き方は出来ますが、英語の通りとしてはwithを使った方が読みやすくなります。

#### 使い時
- 同じオブジェクトに対して繰り返し操作したいとき
- 返り値が必要ないときは apply と同じで、どちらでも使える
- あまり使われてはいない模様

## run
### 定義
```kotlin
public inline fun <T, R> T.run(block: T.() -> R): R = block()
```
![run.png](https://qiita-image-store.s3.amazonaws.com/0/36199/7f95836d-aaf8-3998-904d-6e5da6a99938.png)
> Calls the specified function [block] with `this` value as its receiver and returns its result.

- 自分自身Tをレシーバとする関数を実行し、その結果を返します。
- Kotlin イン・アクションには出てきませんでした。

#### 使用例
```kotlin
val numbers = StringBuilder().run {
    append("Numbers: ")
    for (i in 1..3) append(i)
    toString()
}
println(numbers) // Numbers: 123
```
- withの例はrunでも同じように書けますね。

#### 英語としてわかりやすい例
- 使いどころが限定されていてあまり浮かびません…

#### 使い時
- 人に聞いてみても、あまり使ってないと言われることが多いです。
- エルビス演算子と組み合わせて使うことがあるようです。

## apply
### 定義
```kotlin
public inline fun <T> T.apply(block: T.() -> Unit): T = return this
```
![apply.png](https://qiita-image-store.s3.amazonaws.com/0/36199/bb91c253-1992-68ee-fe3d-369abe0b3578.png)
> Calls the specified function [block] with `this` value as its receiver and returns `this` value.

- 自分自身Tをレシーバとする関数を実行し、実行後の自分自身を返します。
- Kotlin イン・アクション P.171

#### 使用例
withと似た動きをします。異なるのは、applyを実行した返り値はthisなのでStringBuilderであるため、Stringに変換するtoString()が必要な点です。

```kotlin
val numbers = StringBuilder().apply {
    append("Numbers: ")
    for (i in 1..3) append(i)
}.toString()
println(numbers) // Numbers: 123
```

#### 英語としてわかりやすい例
- applyは適用する・適用されるという意味です。設定画面に出てくるapplyのイメージで良さそう。

```kotlin
// Activityで
supportActionBar?.apply {
    setHomeButtonEnabled(true)
    setDisplayHomeAsUpEnabled(true)
}
```

#### 使い時
- ローカル変数を書かずにオブジェクトの状態を変更したいとき。上記「英語としてわかりやすい例」がそれです。
- オブジェクトのインスタンスを生成し、すぐにいくつかのプロパティを初期化する必要があるとき。

```kotlin
val intent = Intent(this, FooActivity::class.java).apply {
    putExtra("id", user.id)
    putExtra("name", user.name)
}
```

## also
### 定義
```kotlin
public inline fun <T> T.also(block: (T) -> Unit): T { block(this); return this }
```
![also.png](https://qiita-image-store.s3.amazonaws.com/0/36199/f34f211c-1e2a-71e1-9042-483c9ba55aa7.png)
> Calls the specified function [block] with `this` value as its argument and returns `this` value.

- 自分自身Tを引数とする関数を実行し、実行後の自分自身を返します。
- Kotlin イン・アクションには出てきませんでした。

#### 使用例
```kotlin
val button = Button(context).also {
    it.text = "hello"
}
```
applyの方がわかりやすくスッキリするようにも見えるのですが、[Kotlinアンチパターン](
https://www.slideshare.net/RecruitLifestyle/kotlin-87339759)で注意事項が書かれていました。


```kotlin
// 最初にこういったコードの内は大丈夫なんですが…
val button = Button(context).apply {
    text = "hello"
}
```

```kotlin
val text = "" // 後でこのコードが追加されると
val button = Button(context).apply {
    text = "hello"
}
button.text // "hello"にならない
```
ということで、applyを禁止してalsoとする場合もあるようです。

#### 使い時
- applyと同じようにまとめて設定を行いたいときで、thisを変えたくないとき

## 自分の使用状況
let と apply をよく使っています。逆に他はほとんど使っていません。
[Kotlinアンチパターン](
https://www.slideshare.net/RecruitLifestyle/kotlin-87339759)の例のように、わかりやすさのために使うスコープ関数の種類を絞るのも有りだと思いました。