fp in scala section 05

勉強会用なので、理解とか答えが間違っていたりすると思います。

Transcript

1. 第５章 正格と遅延 目次 - 第５章 正格と遅延 - 5.1 正格関数と非正格関数 - 5.2 遅延リストの例 - 5.2.1 ストリームを記憶し、再計算を回避する - 5.2.2 ストリームを検査するためのヘルパー関数 - 5.3 プログラムの記述と評価の切り分け - 5.4 無限ストリームと余再帰 - 5.5 まとめ
2. List(1,2,3,4).map(_+10).filter(_%2==0).map(_*3) // res0: List[Int] = List(36,42) Scala では関数がリストを生成して次の関数に渡される。 トレースすると・・・ List(1,2,3,4).map(_+10).filter(_%2==0).map(_*3) // map(_ + 10) を評価 List(11,12,13,14).filter(_%2==0).map(_*3) // filter(_ % 2 == 0) を評価 List(12,14).map(_*3) // map(_*3) を評価 List(36,42)
3. 一時的なデータ構造を作成せずに済ませるには？？ while ループで書き直す。 非正格性(遅延性)を使う。
4. 5.1 正格関数と非正格関数 正格・非正格とは？？ 関数の特性 非正格関数は、引数の１つ以上を評価しない選択が出来る。 正格関数は、引数は常に評価される
5. 論理演算は非正格 false && {println("!!"); true} // 何も出力しない // res0: Boolean = false true || {println("!!"); false} // 何も出力しない // res0: Boolean = true
6. if も非正格 if か elseどちらかしか評価しないので非正格といえる ※ if の条件で使われるパラメータについては必ず評価されるので正格。 val result = if (input.isEmpty) sys.error("empty input") else input
7. scala での非正格関数の記述 def if2[A]( cond: Boolean, onTrue: () => A, onFalse: () => A): A = if (cond) onTrue() else onFalse() if2( a < 22, () => println("a"), () => println("b") ) def if2[A]( cond: Boolean, onTrue: => A, onFlse: => A): A = if (cond) onTrue else onFalse if2(false, sys.error("fail"), 3) () => A , => A どちらの書き方も(デフォルトでは)キャッシュしな い。
8. def maybeTwice(b: Boolean, i: => Int) = if (b) i + i else 0 val x = maybeTwice(true, { println("hi"); 1 + 41}) // hi // hi // x: Int = 84 i + i の部分で２回参照されているので、その都度評価される。
9. def maybeTwice2(b: Boolean, i: => Int) = { lazy val i = i if (b) j + j else 0 } val x = maybeTwice2(true, {println("hi"); 1 +41}) // hi // x: Int = 84 lazy val にすると最初に参照された時に、 初めて評価されて結果がキャッシュされる。 Scala の非正格関数は引数を値渡しではなく、名前渡しで受け取る。
10. 正格性の正式な定義 式の評価がいつまでも終了しない。 あるいは明確な値を返さずにエラーをスローする場合を、 式が終了しない、またはボトムに評価されるといいます。 関数 f が正確となるのは、 ボトムに評価される全ての x に対して、 式 f(x) がボトムに評価される場合です。
11. 5.2 遅延リストの例
12. リスト 5‑2 trait Stream[+A] case object Empty extends Stream[Nothing] case class Cons[+A] (h: () => A, t: () => Stream[A]) extends Stream[A] object Stream { def cons[A](hd: => A, tl: => Stream[A]): Stream[A] = { lazy val head = hd lazy val tail = tl Cons(() => head, () => tail) } def empty[A]: Stream[A] = Empty def apply[A](as: A*): Stream[A] = if (as.isEmpty) empty else cons(as.head, apply(as.tail: _*)) }
13. 関数の作成例 def headOption: Option[A] = this match { case Empty => None case Cons(h, t) => Some(h()) } h() を使ってサンクを強制的に評価。 Cons の末尾である t は評価しない。 これがどう役に立つのか見ていく。
14. 5.2.1 ストリームを記憶し、再計算を回避する val z = Cons(() => expensive(x), tl) val h1 = x.headOption val h2 = x.headOption こう書いてしまうと、 expensive(x) が二回計算されてしまう。 スマートコンストラクタを使うと、それを回避できる。
15. スマートコンストラクタとは コンストラクタとはシグネチャが少し異なるデータ型を生成する関 数のこと。 慣習として対応するデータコンストラクタの１文字目を小文字にし たものを関数名にする。
16. def cons[A](hd: => A, tl: => Stream[A]): Stream[A] = { lazy val head = hd lazy val tail = tl Cons(() => head, () => tail) } 評価結果がキャッシュされる Stream[A] を作ることができる。 def empty[A]: Stream[A] = Empty 型情報がある Empty を生成できるので、型推論に関して都合が良い場合 がある。
17. 5.2.2 ストリームを検査するためのヘルパー関数
18. EXERCISE 5.1 Stream を List に変換し, それによりストリームを強制的に評価する関数 を記述せよ.
19. def toListRecursive: List[A] = this match { case Cons(h,t) => h() :: t().toListRecursive case _ => List() } 末尾再帰 ver def toList: List[A] = { @annotation.tailrec def go(s: Stream[A], acc: List[A]): List[A] = s match { case Cons(h,t) => go(t(), h() :: acc) case _ => acc } go(this, List()).reverse }
20. 最後に reverse するのを避けるために局所的な副作用コーディングをし て高速化 ver (関数に閉じているので、純粋性は保たれている。) def toListFast: List[A] = { val buf = new collection.mutable.ListBuffer[A] @annotation.tailrec def go(s: Stream[A]): List[A] = s match { case Cons(h,t) => buf += h() go(t()) case _ => buf.toList } go(this) }
21. EXERCISE 5.2 Stream の先頭から n 個の要素を取り出す関数 take(n) と, Stream の先頭から n 個の要素をスキップする drop(n) 関数を記述せよ.
22. 自分の答え. def take(n: Int): Stream[A] = this match { case Cons(h, t) if 0 < n => cons(h(), t().take(n - 1)) case _ => empty } 公式の答え. n == 1 のときは empty を詰めるようにすると t() を評価しないで済むた め？？ def take(n: Int): Stream[A] = this match { case Cons(h, t) if n > 1 => cons(h(), t().take(n - 1)) case Cons(h, _) if n == 1 => cons(h(), empty) case _ => empty } @annotation.tailrec final def drop(n: Int): Stream[A] = this match { case Cons(_, t) if n > 0 => t().drop(n - 1) case _ => this }
23. EXERCISE 5.3 Stream の先頭から指定された述語とマッチする要素を全て取り出す takeWhile 関数を記述せよ. def takeWhile(f: A => Boolean): Stream[A] = this match { case Cons(h, t) if f(h()) => cons(h(), t().takeWhile(f)) case _ => empty }
24. 5.3 プログラムの記述と評価の切り分け
25. 遅延を利用することで、式の記述をその式の評価から切り離すことが可 能になる。 def exists(p: A => Boolean): Boolean = this match { case Cons(h, t) => p(h()) || t().exists(p) case _ => false } すべて走査し終える前に、 p(h()) == true を返す場合、それ以降の Streamの末尾は評価されない。
26. これを foldRight を使って再実装できる。 def foldRight[B](z: => B)(f: (A, => B) => B) = this match { case Cons(h, t) => f(h(), t().foldRight(z)(f)) case _ => z } f に渡される二番目の引数が非正格になっているのがポイント。 def exists(p: A => Boolean): Boolean = foldRight(false)((a, b) => p(a) || b) p(a) が true になった場合、b は評価されないで計算が終了する。
27. EXERCISE 5.4 Stream の要素のうち, 指定された述語とマッチする物をすべてチェック する forAll を実装せよ. この実装では, マッチしない値が検出された時点でチェックを終了しなけ ればならない. def forAll(f: A => Boolean): Boolean = foldRight(true)((a, b) => f(a) && b)
28. EXERCISE 5.5 foldRight を使って takeWhile を実装せよ. def takeWhile(f: A => Boolean): Stream[A] = foldRight(empty[A])((h, t) => if (f(h)) cons(h, t) else empty)
29. EXERCISE 5.6 foldRight を使って headOption を実装せよ. def headOption: Option[A] = foldRight(None: Option[A])((h, _) => Some(h))
30. EXERCISE 5.7 foldRight を使って map, filter, append, flatMap を実装せよ. append メソッドはその引数に関して非正格でなければならない.
31. def map[B](f: A => B): Stream[B] = foldRight(empty[B])((h, t) => cons(f(h), t)) def filter(f: A => Boolean): Stream[A] = foldRight(empty[A])((h, t) => if (f(h)) cons(h, t) else t) def append[B >: A](s: => Stream[B]): Stream[B] = foldRight(s)(cons(_, _)) def flatMap[B](f: A => Stream[B]): Stream[B] = foldRight(empty[B])((h, t) => f(h) append t)
32. これらの実装が漸進的であることに注目してください ぜんしん‐ てき【漸進的】 〘形動〙 目的、理想などを急激でなく、 順を追ってだんだんと実現しようとする傾向にあること。 ⇔ 急進的。 例えば、 Stream(1,2,3,4).map(_+10).filter(_%2==0).toList
33. トレースすると・・・ Stream(1,2,3,4).map(_+10).filter(_%2==0).toList // map を１つ目の要素に適用. cons(11, Stream(2,3,4).map(_+10)).filter(_%2==0).toList // filter を１つ目の要素に適用. Stream(2,3,4).map(_+10).filter(_%2==0).toList // map を２つ目の要素に適用. cons(12, Stream(3,4).map(_+10)).filter(_%2==0).toList // filter を２つ目の要素に適用. 12 :: Stream(3,4).map(_+10).filter(_%2==0).toList // map を３つ目の要素に適用. 12 :: cons(13, Stream(4).map(_+10)).filter(_%2==0).toList // filter を３つ目の要素に適用. 12 :: Stream(4).map(_+10).filter(_%2==0).toList // map を４つ目の要素に適用. 12 :: cons(14, Stream().map(_+10)).filter(_%2==0).toList // filter を４つ目の要素に適用. 12 :: 14 :: Stream().map(_+10)).filter(_%2==0).toList // 終了. 12 :: 14 :: List()
34. filter と map の交換が交互に実行されていることがわかる。 中間ストリームがインスタンス化されない。 そのため、ストリームが必要以上に処理されることを心配せずに、 既存のコンビネータを新しい方法で簡単に再利用することが出来 る。
35. def find(p: A => Boolean): Option[A] = filter(p).headOption filter はストリーム全体を変換するが、遅延式なので、find がマッチする ものを検出した時点で終了する。 中間ストリームが生成されないため、ストリームの変換に対しては、 現在の要素を格納して変換するのに必要な作業メモリだけで十分。
36. 5.4 無限ストリームと余再帰
37. 不要と判断された時点でメモリを開放できるので、 無限ストリームを使った処理を書くことが出来る。 val ones: Stream[Int] = Stream.cons(1, ones) ones.take(5).toList // res0: List[Int] = List(1,1,1,1,1) ones.exists(_%2 != 0) // res1: Boolean = true ones.forAll(_==1) など、永遠に終わらない処理や スタックセーフではない式を書いてしまいやすいので注意が必要。 これは、無限ループではなくスタックオーバーフローとして現れる。
38. EXERCISE 5.8 ones を少し一般化し, 指定された値の無限ストリームを返す constant 関 数を記述せよ. def constant[A](a: A): Stream[A] = cons(a, constant(a)) オブジェクトを使い回せる効率が良い ver def constant[A](a: A): Stream[A] = { lazy val tail: Stream[A] = Cons(() => a, () => tail) tail }
39. EXERCISE 5.9 n で始まって n + 1, n + 2 と続く整数の無限ストリームを生成する関数を 記述せよ. def from(n: Int): Stream[Int] = cons(n, from(n + 1))
40. EXERCISE 5.10 フィボナッチ数列(0, 1, 1, 2, 3, 5, 8) の無限ストリームを生成する fibs 関 数を記述せよ. 自分の答え. val fibs: Stream[Int] = cons(0, cons(1, fibs.zip(fibs.tail).map(a => a._1 + a._2))) 公式の答え. val fibs: Stream[Int] = { def go(f0: Int, f1: Int): Stream[Int] = cons(f0, go(f1, f0 + f1)) go(0, 1) }
41. EXERCISE 5.11 より汎用的なストリーム生成関数 unfold を記述せよ. この関数は, 初期状態に加えて, 以下の状態と, 生成されるストリームの次 の値を生成する関数を受け取る. def unfold[A, S](z: S)(f: S => Option[(A, S)]): Stream[A] = f(z) match { case Some((h,s)) => cons(h, unfold(s)(f)) case None => empty }
42. unfold undold 関数は、余再帰(corecursive) と呼ばれる関数の一例。 再帰関数 データを消費する 再帰処理によって入力を小さくしていくことで終了する 余再帰関数 データを生成する "生産性" が続く限り終了する必要がない。 余再帰関数は、ガード付き再帰(guarded recursion)とも呼ばれる 生産性は、相互終了(cotermination)とも呼ばれる
43. EXERCISE 5.12 unfold を使って fibs, from, constant, ones を記述せよ. val fibs: Stream[Int] = unfold[Int, (Int, Int)] ((0, 1))(a => Some((a._1, (a._2, a._1 + a._2)))) def from(n: Int): Stream[Int] = unfold(n)(a => Some(a, a + 1)) def constant[A](a: A): Stream[A] = unfold(a)(_ => Some((a, a))) val ones: Stream[Int] = unfold(1)(_ => Some((1, 1)))
44. EXERCISE 5.13 unfold を使って(第３章で示したような) map, take, takeWhile, zipWith, zipAll を実装せよ. zipAll 関数では, どちらかのストリームに要素が残っている限り, 評価を 続ける必要がある. この関数はストリームが完全に評価されたかどうかを示すのに Option を 使用する.
45. def map[B](f: A => B): Stream[B] = unfold(this) { case Empty => None case Cons(x, xs) => Some((f(x()), xs())) } def take(n: Int): Stream[A] = unfold((this, n)) { case (Empty, _) => None case (_, _n) if _n == 0 => None case (Cons(x, xs), _n) => Some((x(), (xs(), _n - 1))) } def takeWhile(f: A => Boolean): Stream[A] = unfold(this) { case Cons(x, xs) if f(x()) => Some(x(), xs()) case _ => None }
46. def zipWith[B](s:Stream[B])(f:(A,B)=>B): Stream[B] = unfold((this, s)) { case (Cons(x, xs), Cons(y, ys)) => Some((f(x(), y()), (xs(), ys()))) case _ => None } def zipAll[B](s:Stream[B]):Stream[(Option[A],Option[B])] = unfold(this, s) { case (Cons(x, xs), Cons(y, ys)) => Some((Some(x()), Some(y())), (xs(), ys())) case (Cons(x, xs), _) => Some((Some(x()), None), (xs(), Empty)) case (_, Cons(y, ys)) => Some((None, Some(y())), (Empty, ys())) case _ => None }
47. EXERCISE 5.14 難問: ここまで記述してきた関数を使って stratsWith を実装せよ. この関数は, ある Stream が別の Stream のプレフィックス(接頭辞)であ るかどうかを調べる. 例えば, Stream(1,2,3) startsWith Stream(1,2) の結果は true になる. 自分の答え. def stratsWith[B >: A](s: Stream[B]): Boolean = { zipAll(s).takeWhile(t => t._2.isDefined) .foldRight(true)((a, acc) => a._1 == a._2 && acc) } 公式の答え. def startsWith[A](s: Stream[A]): Boolean = zipAll(s).takeWhile(!_._2.isEmpty) forAll { case (h,h2) => h == h2 }
48. EXERCISE 5.15 unfold を使って tails を実装せよ. 与えられた Stream に対し, tails は元の Stream から始まる入力シーケン スのサフィックス(接尾辞)である Stream を返す. 例えば Stream(1,2,3) が与えられた場合は, Stream(Stream(1,2,3), Stream(2,3), Stream(3), Stream()) を返す. 自分の答え. def tails: Stream[Stream[A]] = unfold(this) { case Empty => None case s@Cons(_, t) => Some((s, t())) } append Stream(empty) 公式の答え. def tails: Stream[Stream[A]] = unfold(this) { case Empty => None case s => Some((s, s drop 1)) } append Stream(empty)
49. EXERCISE 5.16 難問: tails を scanRight 関数として一般化せよ. foldRight と同様に, この関数は中間結果をストリームで返す. scala> Stream(1,2,3).scanRight(0)(_ + _).toList res0: List[Int] = List(6,5,3,0) この例は式 List(1+2+3+0, 2+3+0, 3+0, 0) と同じ意味になるはずであ る. scanRight 関数では, 中間結果を再利用することで, n 個の要素を持つ Stream の評価にかかる時間が常に n に対して線形になるようにすべきで ある. この実装に unfold を使用することは可能か. その場合はどのようになる か, あるいは, 実装できないのであればそれはなぜか. すでに記述した別の関数を使って実装することは可能か.
50. unfold を使って、一応実装自体は出来るが・・・ def _scanRight[B](z:=>B)(f:(A,=>B)=>B):Stream[B] = unfold((this, z)) { case (_this@Cons(_, t), _z) => Some((_this.foldRight(_z)(f), (t(), _z))) case _ => None } append Stream(z) scanRight 関数では, 中間結果を再利用することで, n 個の要素を持 つ Stream の評価にかかる時間が常に n に対して線形になるように すべきである. この部分が、無理っぽい。 scanRight は、右から左に中間結果を累積していく必要があるが、 unfold は、左から右への処理になるため、中間結果を再利用することが 出来ないため。
51. 公式の答え. def scanRight[B](z: B)(f: (A, => B) => B): Stream[B] = foldRight((z, Stream(z)))((a, p0) => { lazy val p1 = p0 val b2 = f(a, p1._1) (b2, cons(b2, p1._2)) })._2 scanRight を使って再実装した tails def tails: Stream[Stream[A]] = scanRight(empty[A])((a, acc) => cons(a, acc))
52. 5.5 まとめ 非正格性は、式の記述をその評価の方法やタイミングから切り離すこと で、モジュール性を向上させることを目的としている。 これにより、同じ記述を複数のコンテキストで再利用することが可能に なる。 それは、正格なコードでは出来ないことである。