class: center, middle # ループで遊ぼう 市ヶ谷Geek★Night #3 2015/08/25 --- class: left, middle ## 自己紹介 * 中村 学(Nakamura Manabu) * [@gakuzzzz](https://twitter.com/gakuzzzz) * 株式会社 Tech to Value * [Scala Matsuri 2016](http://scalamatsuri.org/) よろしくおねがいします！ * 隔週で[rpscala](https://rpscala.doorkeeper.jp/) という勉強会やってます。<br>明日8/26あるので良かったら --- class: middle ## [セッション募集中](http://scalamatsuri.org/ja/cfp/)です  --- class: middle ## 今日の内容 * ループの書き換えを通してScalaの表現力を見る * 関数型的な手法のメリット --- class: middle 最初のコード ```scala case class Product(id: ProductId, name: Name) def createItem(product: Product): Item = ??? def createCodes(name: Name, item: Item): List[Code] = ??? ``` ```scala val products: List[Product] = ??? val allItemsBuf: mutable.ListBuffer[Item] = mutable.ListBuffer() val allCodesBuf: mutable.ListBuffer[Code] = mutable.ListBuffer() for (product <- products) { val item = createItem(product) allItemsBuf += item allCodesBuf ++= createCodes(product.name, item) } val allItems = allItemsBuf.toList val allCodes = allCodesBuf.toList ``` --- class: middle 高階関数を使って書き直せる。 ```scala def createItem(product: Product): Item = ??? def createCodes(name: Name, item: Item): List[Code] = ??? ``` ```scala val products: List[Product] = ??? val allItems = products.map(createItem) val allCodes = products.flatMap { p => createCodes(p.name, createItem(p)) } ``` ## やった！ mutable が無くなった！<br>　 --- class: middle シンプルにはなった。けれど…… ```scala def createItem(product: Product): Item = ??? def createCodes(name: Name, item: Item): List[Code] = ??? ``` ```scala val products: List[Product] = ??? val allItems = products.map(createItem) val allCodes = products.flatMap { p => createCodes(p.name, createItem(p)) } ``` ## **２回**全件ループしてしまっている<br>createItem も２重に実行している --- class: center, middle ## Monoid の導入 --- class: middle ## Monoid とは 以下の性質を満たす集合と2項演算の組み合わせ * 演算結果も集合の要素である(演算に対し閉じている) * 基本的に集合は型で表す * つまり引数の型と戻り値の型が同じという事 * 演算が結合法則を満たす * `a`, `b`, `c` を集合の要素として、演算を `|+|` とした時<br>`(a |+| b) |+| c == a |+| (b |+| c)` が成り立つという事 * 交換法則(可換則) ではない事に注意 * 単位元が存在する * `e |+| a == a` * `a == a |+| e` * 全ての要素に対して上記が成り立つ e が存在するという事 --- class: middle ## 例えば * 整数と足し算 * 整数 + 整数 = 整数 (演算に対し閉じている) * `(1 + 2) + 3 == 1 + (2 + 3)` (結合法則を満たす) * `0 + a == a` かつ `a + 0 == a` (単位元 0 が存在する) * Listと連結 * `List[Int] ++ List[Int]` の結果は `List[Int]` * `(List(1) ++ List(2)) ++ List(3) == `<br>　　　　　`List(1) ++ (List(2) ++ List(3))` * `List() ++ List(1) == List(1)` かつ `List(2) ++ List() == List(2)` --- class: middle ## Monoidではない例 * 整数と割り算 * 整数÷整数の結果は整数とは限らない(演算に対し閉じていない) * 整数と引き算 * `(1 - 2) - 3 != 1 - (2 - 3)`(結合法則を満たさない) --- class: middle コードにすると以下の様に ```scala trait Monoid[A] { // A型が集合を表し def op(a: A, b: A): A // op が二項演算 def zero: A // zeroが単位元を表す } ``` ```scala val sum: Monoid[Int] = new Monoid[Int] { def op(a: Int, b: Int): Int = a + b def zero: Int = 0 } ``` ```scala def concat[A]: Monoid[List[A]] = new Monoid[List[A]] { def op(a: List[A], b: List[A]): List[A] = a ++ b def zero: List[A] = List() } ``` --- class: middle ## Monoid をどう使うのか 畳み込み処理 ```scala scala> List(1, 2, 3).foldLeft(0)(_ + _) res0: Int = 6 // 0 + 1 + 2 + 3 ``` --- class: middle ## もし List の要素が Monoid だったら ```scala List(...).foldLeft(単位元)(2項演算) ``` 畳み込みが可能！！ ```scala List(1, 2, 3).foldLeft(sum.zero)(sum.op) res0: Int = 6 // 0 + 1 + 2 + 3 ``` ```scala val c = concat[Int] // 画面幅の都合で代入 List(List(1, 2), List(3)).foldLeft(c.zero)(c.op) res1: List[Int] = List(1, 2, 3) // List() ++ List(1, 2) ++ List(3) ``` --- class: middle ## でも常に要素が Monoid とは限らない --- class: middle ## そこで foldMap を定義 ```scala def foldMap[A, B](list: List[A], mb: Monoid[B])(f: A => B): B = { list.foldLeft(mb.zero) { (a, b) => mb.op(a, f(b)) } } ``` <section> flatMap が map して flatten するイメージなら<br> foldMap は map して fold するイメージ </section> --- class: middle ## この foldMap を使うと ```scala val list1 = List("abc", "d", "ef") foldMap(list1, sum)(_.size) res0: Int = 6 // 0 + 3 + 1 + 2 ``` ```scala val list2 = List(List("ab", "c"), List("def")) foldMap(list2, concat[Int])(_.map(_.size)) res1: List[Int] = List(2, 1, 3) // List() ++ List(2, 1) ++ List(3) ``` ある型のMonoidインスタンスと、その型への変換処理を渡すだけで簡単に畳み込みができる --- class: middle ## 毎回Monoid値を渡すのは面倒 --- class: middle ## Implicit引数の導入 --- class: middle 最後の引数グループに implicit をつけると、そのグループの全ての引数は implicit parameter になる ```scala def foldMap[A, B](list: List[A]) (f: A => B)(implicit mb: Monoid[B]): B = { list.foldLeft(mb.zero) { (a, b) => mb.op(a, f(b)) } } ``` --- class: middle implicit parameter はスコープ中に<strong>同じ型</strong>のimplicitな値があればコンパイル時に自動的に挿入される ```scala // implicitな値とは、単に定義時にimplicitキーワードをつけた値の事 implicit val sum: Monoid[Int] = new Monoid[Int] { def op(a: Int, b: Int): Int = a + b def zero: Int = 0 } implicit def concat[A]: Monoid[List[A]] = new Monoid[List[A]] { def op(a: List[A], b: List[A]): List[A] = a ++ b def zero: List[A] = List() } foldMap(List("abc", "d", "ef"))(_.size) // _.size が Int を返すため Monoid[Int] が必要となり sumが補われる ``` スコープ中にimplicitな値が無ければコンパイルエラー --- class: middle これを使うと最初の例(再掲)も ```scala def createItem(product: Product): Item = ??? def createCodes(name: Name, item: Item): List[Code] = ??? ``` ```scala val products: List[Product] = ??? val allItems = products.map(createItem) val allCodes = products.flatMap { p => createCodes(p.name, createItem(p)) } ``` 　<br> --- class: middle foldMap で書き直せる ```scala def createItem(product: Product): Item = ??? def createCodes(name: Name, item: Item): List[Code] = ??? ``` ```scala val products: List[Product] = ??? val allItems = foldMap(products) { p => List(createItem(p)) } val allCodes = foldMap(products) { p => createCodes(p.name, createItem(p)) } ``` でもこれでは 2回ループしてるのは変わらない --- class: middle ## Monoid は<strong style="color: blue">合成</strong>できる --- class: middle 2つの Monoid[A] と Monoid[B] を元に タプルのモノイド、Monoid[(A, B)] を定義することが可能 ```scala implicit def tuple2[A, B]( implicit ma: Monoid[A], mb: Monoid[B]): Monoid[(A, B)] = { new Monoid[(A, B)] { def zero: (A, B) = (ma.zero, mb.zero) def op(x: (A, B), y: (A, B)): (A, B) = { (ma.op(x._1, y._1), mb.op(x._2, y._2)) } } } ``` <section> タプルとは複数の型の組み合わせを表現できる型。<br> 標準で Tuple2 ～ Tuple22 まで定義されている。<br> Tuple2[A, B] という型を (A, B) と書く省略記法がある。 </section> --- class: middle このタプルのMonoidを使う事で、以下(再掲)を ```scala def createItem(product: Product): Item = ??? def createCodes(name: Name, item: Item): List[Code] = ??? ``` ```scala val products: List[Product] = ??? val allItems = foldMap(products) { p => List(createItem(p)) } val allCodes = foldMap(products) { p => createCodes(p.name, createItem(p)) } ``` ## 　 --- class: middle **1回**のループに書き換える事ができる ```scala def createItem(product: Product): Item = ??? def createCodes(name: Name, item: Item): List[Code] = ??? ``` ```scala val products: List[Product] = ??? val (allItems, allCodes) = foldMap(products) { p => val item = createItem(p) (List(item), createCodes(p.name, item)) } ``` <section> Scalaでは変数の宣言時にパターンマッチが使用できる。<br> foldMapの結果が (List[Item], List[Code]) を返すので<br> それぞれ allItems に List[Item] が、<br>allCodes に List[Code] が代入される。 </section> --- class: middle ## なぜ普通の for じゃだめなのか？ --- class: middle 最初のコードをテストしようと思ったらループ全体をテストする必要がある。 ```scala val products: List[Product] = ??? val allItemsBuf: mutable.ListBuffer[Item] = mutable.ListBuffer() val allCodesBuf: mutable.ListBuffer[Code] = mutable.ListBuffer() for (product <- products) { val item = createItem(product) allItemsBuf += item allCodesBuf ++= createCodes(product.name, item) } val allItems = allItemsBuf.toList val allCodes = allCodesBuf.toList ``` <section> もちろんループの中身を<br> 1件のProductと2つのListBufferを受け取るように<br> 括りだして、テストを書くことは可能だが、<br> コードは追い辛いし素直に書くより書き辛い。 </section> --- class: middle Monoid を使ったループでは、<br> 1件のProductをタプルに変換するテストと<br> ループ処理全体のテストと<br> を**分けてテスト**ができる。 ```scala val products: List[Product] = ??? val (allItems, allCodes) = foldMap(products) { p => val item = createItem(p) (List(item), createCodes(p.name, item)) } ``` --- class: middle Monoid を使ったループでは、<br> 前後の状態に依存しないし<br> 結合則が保証されているので、<br> リストを細かく分割するなどして、<br> **並列処理**する事が可能になる。 ```scala val products: List[Product] = ??? val (allItems, allCodes) = foldMap(products) { p => val item = createItem(p) (List(item), createCodes(p.name, item)) } ``` --- class: middle ## まとめ * 巨大な集合に対する状態を持った複雑なループも<br>Monoidを使うことで簡潔に記述できる場合がある * ループから状態を取り除く事で、<br>1件単位の処理に集中でき、テストが書きやすくなる * ループから状態を取り除く事で、<br>処理順を気にする必要が無くなり、<br>並列化などのパフォーマンス改善を計ることができる --- class: middle ## 宣伝 --- class: middle ## Scalaオンラインコードレビュー * チームメンバーにScalaのスペシャリストが居ない * もっと業務コードに密接に絡んだ質問がしたい などなどありましたら是非[Scalaコードレビューサービス](http://www.t2v.jp/#service)の利用をご検討ください。 --- class: middle ## お申し込み * [弊社Webサイト](http://www.t2v.jp/)の申し込みフォーム * Twitter [@gakuzzzz](https://twitter.com/gakuzzzz/) にメンション or DM --- class: middle ## 質問とか