ラムダ式禁止おじさん ver1.1 #Kotlin_Sansan

第4回Kotlin勉強会 ＠ Sansan ( https://connpass.com/event/44710/ )で発表したスライドです。

Transcript

1. ラムダ式禁止おじさん 〜もうすぐver 1.1が来るバージョン〜 2016-12-13 第4回Kotlin勉強会@Sansan 長澤 太郎 @ngsw_taro
2. Kotlinってラムダ式使えて快適〜(^q^) list .filter { it % 3 == 0 } .fold(0) { a, e -> a + e } .let { println(it) }
3. おじさん曰く
4. ラムダ式は 難しい！ おじさん曰く
5. 複数の文が入り込む余地があるのが... list .filter { hoge(); fuga(); piyo(); it % 3 == 0 } .fold(0) { a, e -> a + e } .let { println(it) }
6. ラムダ式なんか禁止だ〜〜〜〜〜！！！ list .filter(myCondition) .fold(0, Int::plus) .let(::println)
7. トリにして ネタ枠 です
8. もくじ 1. 関数参照・メソッド参照 2. カリー化、関数の部分適用 3. Java的なメソッド参照 4. nullableどうするの問題 5. まとめと注意事項
9. 自己紹介 • 長澤 太郎 たろーって呼んでね ◦ @ngsw_taro • エンジニア@エムスリー株式会社 ◦ ITで医療を変革！ ◦ Android, Kotlin, Java, Spring, Railsなど • Kotlinエバンジェリスト • ディズニーが好き
10. 1. 関数参照・メソッド参照
11. 引数を1つだけ取る関数 123.let { println(it) }
12. 引数を1つだけ取る関数 123.let { println(it) } ここのラムダ式をなくしたい！
13. 関数参照 val println: (Int) -> Unit = ::println 123.let(println) 123.let(::println)
14. 関数参照 val println: (Int) -> Unit = ::println 123.let(println) 123.let(::println) 関数オブジェクトへの 参照を取得できる
15. 関数参照 val println: (Int) -> Unit = ::println 123.let(println) 123.let(::println) 関数の型
16. 関数参照 val println: (Int) -> Unit = ::println 123.let(println) 123.let(::println) 普通に引数として渡すだけ
17. 関数参照 val println: (Int) -> Unit = ::println 123.let(println) 123.let(::println) もちろん直接もOK！
18. 引数を取らないメソッド "hoge".let { it.toUpperCase() }
19. 引数を取らないメソッド "hoge".let { it.toUpperCase() } ここのラムダ式をなくしたい！
20. メソッド参照 val toUpperCase: String.()->String = String::toUpperCase "hoge".let(toUpperCase)
21. メソッド参照 val toUpperCase: String.()->String = String::toUpperCase "hoge".let(toUpperCase) 関数オブジェクトへの 参照を取得できる
22. メソッド参照 val toUpperCase: String.()->String = String::toUpperCase "hoge".let(toUpperCase) 関数の型
23. メソッド参照 val toUpperCase: String.()->String = String::toUpperCase "hoge".let(toUpperCase) レシーバの型
24. メソッド参照 val toUpperCase: String.()->String = String::toUpperCase "hoge".let(toUpperCase) 引数リスト->戻り型
25. メソッド参照 val toUpperCase: String.()->String = String::toUpperCase "hoge".let(toUpperCase) 普通に引数として渡すだけ
26. できたこと 123.let { println(it) } 123.let(::println) "hoge".let { it.toUpperCase() } "hoge".let(String::toUpperCase)
27. 2. カリー化、関数の部分適用
28. 引数を2つ取る関数 fun minus(a: Int, b: Int) = a - b 3.let { minus(5, it) } //=> 2 ここのラムダ式をなくしたい！
29. デフォルトでカリー化してるっぽく見せる operator fun <A, B, R> ((A, B) -> R).invoke(a: A): (B) -> R = { this(a, it) }
30. デフォルトでカリー化してるっぽく見せる operator fun <A, B, R> ((A, B) -> R).invoke(a: A): (B) -> R = { this(a, it) } 「AとBを引数に取り、Rを返す関数」に 拡張関数invokeを生やす
31. デフォルトでカリー化してるっぽく見せる operator fun <A, B, R> ((A, B) -> R).invoke(a: A): (B) -> R = { this(a, it) } Aを引数に取り、 「Bを引数に取り、Rを返す関数」を返す
32. デフォルトでカリー化してるっぽく見せる operator fun <A, B, R> ((A, B) -> R).invoke(a: A): (B) -> R = { this(a, it) } 演算子オーバロードにより function2.invoke(foo) ↓ function2(foo)
33. デフォルトでカリー化してるっぽく見せる operator fun <A, B, R> ((A, B) -> R).invoke(a: A): (B) -> R = { this(a, it) } つまり、invoke関数の存在によって (A, B)->R を (A)->((B)->R) とも見なせる
34. デフォルトでカリー化してるっぽく見せる operator fun <A, B, R> ((A, B) -> R).invoke(a: A): (B) -> R = { this(a, it) } ※invokeはカリー化する関数ではありません。 ((A, B)->R)が1引数関数に見えるようにするための関数です。 あくまで「カリー化してるっぽく」見せているだけです。
35. minusを1引数関数として使える！ fun minus(a: Int, b: Int) = a - b (::minus)(5, 2) //=> 3 val x = (::minus)(5) x(2) //=> 3 (::minus)(5)(2) //=> 3
36. ラムダ式を消せる！ 3.let { minus(5, it) } //=> 2 3.let((::minus)(5)) //=> 2
37. 引数の位置を変えたい問題 5.let { minus(it, 3) } //=> 2 5.let((::minus)(3)) //=> -2
38. 関数の部分適用 5.let { minus(it, 3) } //=> 2 5.let((::minus)(3)) //=> -2 5.let((::minus)(_, 3)) //=> 2 プレースホルダーを置いて、 引数の位置をコントロールしたい！
39. プレースホルダー enum class PlaceHolder { アレ }
40. プレースホルダーを取る拡張関数invoke operator fun <A, B, R> ((A, B) -> R).invoke(p: PlaceHolder, b: B): (A) -> R = { this(it, b) }
41. プレースホルダーを取る拡張関数invoke operator fun <A, B, R> ((A, B) -> R).invoke(p: PlaceHolder, b: B): (A) -> R = { this(it, b) } 「AとBを引数に取り、Rを返す関数」に 拡張関数invokeを生やす
42. プレースホルダーを取る拡張関数invoke operator fun <A, B, R> ((A, B) -> R).invoke(p: PlaceHolder, b: B): (A) -> R = { this(it, b) } プレースホルダーとBを引数に取り、 「Aを取ってRを返す関数」を返す
43. 1引数バージョンのminusを自在に使える (::minus)(5, 3) //=> 2 (::minus)(アレ, 3)(5) //=> 2
44. ラムダ式を消せる！ 5.let { minus(it, 3) } //=> 2 5.let((::minus)(アレ, 3)) //=> 2
45. 3. Java的なメソッド参照
46. レシーバが指定されたメソッド参照 // Javaコード static class Calculator { int succ(int x) { return x + 1; } } public static void main(final String... args) { final Calculator c = new Calculator(); Optional.of(5).map(c::succ); }
47. レシーバが指定されたメソッド参照 // Javaコード static class Calculator { int succ(int x) { return x + 1; } } public static void main(final String... args) { final Calculator c = new Calculator(); Optional.of(5).map(c::succ); } 「c」のsuccメソッド
48. 一方、Kotlinは... class Calculator { fun succ(x: Int): Int = x + 1 } val calc = Calculator() 2.let(calc::succ) // NG 2.let { calc.succ(it) } // こう書くしか…？
49. T.(A)->Rは、(T, A)->Rでもある！ class Calculator { fun succ(x: Int): Int = x + 1 } val a: Calculator.(Int)->Int = Calculator::succ val b: (Calculator, Int)-> Int = a
50. T.(A)->Rは、(T, A)->Rでもある！ class Calculator { fun succ(x: Int): Int = x + 1 } val a: Calculator.(Int)->Int = Calculator::succ val b: (Calculator, Int)-> Int = a
51. つまり val calc = Calculator() 2.let(calc::succ) // NG 2.let { calc.succ(it) } // OK 2.let { (Calculator::succ)(calc, it) } // OK
52. さらに val calc = Calculator() 2.let(calc::succ) // NG 2.let { calc.succ(it) } // OK 2.let { (Calculator::succ)(calc, it) } // OK 2.let((Calculator::succ)(calc)) // OK
53. さらに val calc = Calculator() 2.let(calc::succ) // NG 2.let { calc.succ(it) } // OK 2.let { (Calculator::succ)(calc, it) } // OK 2.let((Calculator::succ)(calc)) // OK 既にカリー化する方法を知っているので、 it を省略して、ラムダ式を消せる！
54. ちょっと待った！！ class Calculator { fun succ(x: Int): Int = x + 1 } val calc = Calculator() 2.let(calc::succ) // NG 2.let { calc.succ(it) } // こう書くしか…？
55. ちょっと待った！！ class Calculator { fun succ(x: Int): Int = x + 1 } val calc = Calculator() 2.let(calc::succ) // OK ver1.1から 2.let { calc.succ(it) } // こう書くしか…？ ラムダ式禁止が捗るね！！
56. 4. nullableどうするの問題
57. 安全呼び出しするためには、ラムダ式が... setOf<Int?>(2).map { it?.let(::succ) } setOf<Int?>(2).map { it?.inc() }
58. 安全呼び出しするためには、ラムダ式が... setOf<Int?>(2).map { it?.let(::succ) } setOf<Int?>(2).map { it?.inc() }
59. 関数のnullable対応 fun <A, R> ((A) -> R).nullOk(): (A?) -> R? = { it?.let(this@nullOk) }
60. 関数のnullable対応 fun <A, R> ((A) -> R).nullOk(): (A?) -> R? = { it?.let(this@nullOk) } 普通の関数を取って
61. 関数のnullable対応 fun <A, R> ((A) -> R).nullOk(): (A?) -> R? = { it?.let(this@nullOk) } 「nullableを取って、 nullableを返す関数」を返す
62. ラムダ式を消せる setOf<Int?>(2).map { it?.let(::succ) } setOf<Int?>(2).map { it?.inc() } setOf<Int?>(2).map(::succ.nullOk()) setOf<Int?>(2).map(Int::inc.nullOk())
63. 5. まとめと注意事項
64. まとめ • 関数参照、メソッド参照により、スッキリしたコードが書ける • カリー化や関数の部分適用により、無理やり1引数関数の形 にして、ラムダ式を排除できる • Java的なメソッド参照のような記法は使えない。しかし、無理 やり1引数関数の形にして、ラムダ式を排除できる →ver1.1 から可能に！ • notNullを取る関数を持ち上げて、無理やりnullableに対応さ せ、ラムダ式を排除できる
65. 注意事項 • ラムダ式を使いましょう • 「単純な関数参照」はOK • ちょっと複雑な関数参照は、インライン展開されない場合が多 く、パフォーマンスに影響あり • わざわざトリッキーなコード書くな（怒）
66. Thank you Enjoy Kotlin!