Essential Scala 第5章シーケンス処理 / Essential Scala Chapter 5 Sequencing Computations

Slide 1

Slide 1 text

Essential Scala 第5章シーケンス処理 2018.9.12 Takuya Tsuchida (@takuya0301)

Slide 2

Slide 2 text

第5章シーケンス処理 5.1 総称 5.2 関数 5.3 総称データのための総称畳み込み 5.4 総称型によるデータモデリング 5.5 シーケンス処理 5.6 変位 5.7 まとめ 2

Slide 3

Slide 3 text

第5章シーケンス処理本章ではさらに2つの言語機能である総称と関数を見ていきます。そして、それらの機能を使用して構築する抽象化の関手とモナドも見ていきます。前章で開発したコードから始めます。整数のリストである IntList を開発し、課題で下記のようなコードを書きました。 sealed trait IntList { def sum: Int = this match { case End => 0 case Pair(hd, tl) => hd + tl.sum } } final case object End extends IntList final case class Pair(head: Int, tail: IntList) extends IntList

Slide 4

Slide 4 text

No content

Slide 5

Slide 5 text

第5章シーケンス処理このコードには2つの問題があります。1つ目はリストが Int に強く制限されていることです。2つ目は多くの繰り返しがあることです。このコードは共通の構造を持っているので、構造的再帰パターンを適用することに違和感はなく、多くの重複を削減できるでしょう。本章ではこれら両方の問題に注力します。前半で型を抽象化する総称を使用し、ユーザーが指定した型で動作するデータを作成します。後半でメソッドを抽象化する関数を使用し、コードの重複を削減します。それらのテクニックを適用することで、いくつかの一般的なパターンが出現します。本章の最後で、それらのパターンに名前を付け、詳細に研究してみることにしましょう。

Slide 6

Slide 6 text

5.1 総称総称型は型を抽象化することを可能にします。すべてのデータ構造において有用ですが、一般にコレクションで遭遇するので、そこから始めていきましょう。

Slide 7

Slide 7 text

5.1.1 パンドラの箱リストよりシンプルなコレクション、単一の値を保持する Box から始めます。Box にどんな型が保持されるかは気にしたくないですが、Box から値を取り出したとき、その型を維持してほしいです。これを総称型を使用して実現します。 final case class Box[A](value: A) Box(2) // res0: Box[Int] = Box(2) res0.value // res1: Int = 2 Box("hi") // 型引数を省略すると Scala は値から型を推論する // res2: Box[String] = Box(hi) res2.value // res3: String = hi

Slide 8

Slide 8 text

No content

Slide 9

Slide 9 text

5.1.1 パンドラの箱 [A] という文法は型引数と呼ばれます。型引数はメソッドにも付与でき、メソッドの宣言と本体にその引数のスコープを限定します。 def generic[A](in: A): A = in generic[String]("foo") // res: String = foo generic(1) // 型引数を省略すると Scala は値から型を推論する // res: Int = 1

Slide 10

Slide 10 text

No content

Slide 11

Slide 11 text

5.1.1 パンドラの箱型引数はメソッド引数と類似した動作をします。メソッドを呼ぶときにメソッド引数名に値を束縛します。generic(1) と呼ぶとき、引数 in は generic の本体で1という値に束縛されます。型引数を伴うメソッドやコンストラクターを呼ぶとき、型引数はメソッドやクラス本体で具象型に束縛します。generic(1) と呼ぶとき、型引数 A は generic の本体で Int に束縛されます。

Slide 12

Slide 12 text

ノート：型パラメーター文法総称型は [A, B, C] のようにブラケットのリストで宣言する。慣例として総称型には1文字の大文字を使用する。総称型はクラス宣言やトレイト宣言において宣言され、その宣言における残りの部分で登場できる。 case class Name[A](...){ ... } trait Name[A]{ ... } あるいは、メソッド宣言で宣言され、メソッド内で登場できる。 def name[A](...){ ... } 12

Slide 13

Slide 13 text

5.1.2 総称代数的データ型メソッド引数に類似する型引数を説明し、型引数を持つトレイトを拡張するときも類似しています。直和型でしたように、トレイトを拡張することは、メソッド呼び出しについて型のレベルで等価で、拡張したトレイトのどんな型引数についても値を供給しなければなりません。前章で下記のような直和型を見ました。 sealed trait Calculation final case class Success(result: Double) extends Calculation final case class Failure(reason: String) extends Calculation

Slide 14

Slide 14 text

No content

Slide 15

Slide 15 text

5.1.2 総称代数的データ型結果が Double に限定されず、総称型になるよう、これを総称化してみます。また、数値計算に制限されないよう Calculation を Result という名前にします。型 A の Result は型 A の Success か String の文字列を伴う Failure です。 sealed trait Result[A] case class Success[A](result: A) extends Result[A] case class Failure[A](reason: String) extends Result[A] Success と Failure のどちらも、Result を拡張するところで渡される型引数 A を導入していることに気付きます。Success は型 A の値を持っていますが、Failure は型 A を導入しているだけです。後節で変位を導入するときに、この実装について明快な方針を示します。

Slide 16

Slide 16 text

No content

Slide 17

Slide 17 text

ノート：非変総称直和型パターン型 T の A が B か C である場合、このように記述する。 sealed trait A[T] final case class B[T]() extends A[T] final case class C[T]() extends A[T] 17

Slide 18

Slide 18 text

5.2 関数関数はメソッドを抽象化することを可能にし、プログラムの中で渡したり操作したりできるようにメソッドを値に変化させます。前述の IntList を操作するメソッドを見てみましょう。

Slide 19

Slide 19 text

sealed trait IntList { def length: Int = this match { case End => 0 case Pair(hd, tl) => 1 + tl.length } def double: IntList = this match { case End => End case Pair(hd, tl) => Pair(hd * 2, tl.double) } def product: Int = this match { case End => 1 case Pair(hd, tl) => hd * tl.product } def sum: Int = this match { case End => 0 case Pair(hd, tl) => hd + tl.sum } } final case object End extends IntList final case class Pair(head: Int, tail: IntList) extends IntList

Slide 20

Slide 20 text

No content

Slide 21

Slide 21 text

No content

Slide 22

Slide 22 text

5.2 関数メソッドのすべてが共通のパターンを持つことは、それらすべてが構造的再帰を使用していることからも驚きはありません。その重複を取り除くことができたら素敵です。 Int を返すメソッド、length、product、sumにフォーカスしてみると、そのメソッドはこのように書けます。 def abstraction(end: Int, f: ???): Int = this match { case End => end case Pair(hd, tl) => f(hd, tl.abstraction(end, f)) }

Slide 23

Slide 23 text

5.2 関数 Pair ケースにおいて、先頭と再帰呼び出しの組み合わせを処理するあるオブジェクトを記述するのに f を使用しました。この値の型を書き下す方法も知りませんし、それを構築する方法も知りません。しかし、この節のタイトルから恐らく推測できるでしょう。ここで必要なのは関数であるということを！関数はメソッドのようなもので、引数と共に呼び出すことができ、結果に評価されます。メソッドと違って関数は値です。関数はメソッドやほかの関数に渡すことができます。また、メソッドから関数を返すことも可能です。

Slide 24

Slide 24 text

5.2 関数本稿の序盤で、文法の仕組みによってオブジェクトを関数として取り扱える apply メソッドを紹介しました。 object add1 { def apply(in: Int) = in + 1 } add1(2) // res: Int = 3 これは Scala で本物の関数プログラミングを実現するための大きな進歩ですが、型という大事なコンポーネントのひとつを見逃しています。Scala の関数型を見ていきましょう。

Slide 25

Slide 25 text

No content

Slide 26

Slide 26 text

5.2.1 関数型関数型は (A, B) => C というように書け、A と B は引数型を、C は結果型を表現します。同じパターンで無引数や有引数の関数を一般化します。 2つの Int を引数として Int を返す関数 f としたいならば、(Int, Int) => Int と記述します。

Slide 27

Slide 27 text

ノート：関数型宣言文法関数型は下記のように宣言する。 (A, B, ...) => C ● A, B, ... は引数型 ● C は結果型関数がひとつの引数だけである場合は、括弧を省略できる。 A => B 27

Slide 28

Slide 28 text

5.2.2 関数リテラル Scala は新しい関数を生成する関数リテラル文法を与えてくれます。 val sayHi = () => "Hi!" // sayHi: () => String = sayHi() // res: String = Hi! val add1 = (x: Int) => x + 1 // add1: Int => Int = add1(10) // res: Int = 11 val sum = (x: Int, y: Int) => x + y // sum: (Int, Int) => Int = sum(10, 20) // res: Int = 30

Slide 29

Slide 29 text

No content

Slide 30

Slide 30 text

5.2.2 関数リテラル引数型が既知であるコードにおいて、型注釈を省略することができ、Scala が推論してくれます。関数の結果型を宣言する文法はなく、通常それは推論されますが、関数本体の式に型を指定することでも実現できます。 (x: Int) => (x + 1): Int

Slide 31

Slide 31 text

ノート：関数リテラル文法関数リテラルは下記のように宣言する。 (parameter: type, ...) => expression ● parameter は関数引数の名前（省略可能） ● type は関数引数の型 ● expression は関数の結果を決定する 31

Slide 32

Slide 32 text

5.3 総称データのための総称畳み込み総称データのクラスを定義するのを見てきましたが、クラス上にたくさんのメソッドを実装はしませんでした。ユーザーは総称型を供給し、さらにユーザーにその型で機能する関数を供給することを要請します。それでもやはり、そこには総称データを使用するいくつかの共通パターンがあり、それをこの節で探索していきます。IntList の文脈で畳み込みはすでに見ています。ここで畳み込み (fold) の詳細を探索していき、様々な代数的データ型について畳み込みを実装するパターンについて学びます。

Slide 33

Slide 33 text

5.3.1 畳み込み (Fold) 整数型のリストを処理する畳み込みを見ました。総称型のリストに一般化してみましょう。必要な道具はすでに見てきています。最初にデータ定義を不変直和型パターンを使用して少し修正します。 sealed trait LinkedList[A] final case class Pair[A](head: A, tail: LinkedList[A]) extends LinkedList[A] final case class End[A]() extends LinkedList[A]

Slide 34

Slide 34 text

5.3.1 畳み込み IntList で見た畳み込みの最終バージョンは下記のとおりです。 def fold[A](end: A, f: (Int, A) => A): A = this match { case End => end case Pair(hd, tl) => f(hd, tl.fold(end, f)) }

Slide 35

Slide 35 text

5.3.1 畳み込み LinkedList[A] を拡張するのはかなり素直な対応です。単に Pair の先頭要素を Int ではなく型 A にするだけです。 sealed trait LinkedList[A] { def fold[B](end: B, f: (A, B) => B): B = this match { case End() => end case Pair(hd, tl) => f(hd, tl.fold(end, f)) } } final case class Pair[A](head: A, tail: LinkedList[A]) extends LinkedList[A] final case class End[A]() extends LinkedList[A]

Slide 36

Slide 36 text

No content

Slide 37

Slide 37 text

5.3.1 畳み込み畳み込みはちょうど構造的再帰の適応で、ユーザーが関数にそれぞれの場合に適用するものを渡すことができます。構造的再帰としての代数的データ型を変換する関数を書くための総称的パターンで、畳み込みはこの総称的パターンの具体的な実装です。畳み込みは総称的変換と反復処理です。どんな関数も代数的データ型について書くときは畳み込みという手段で書けるか気にかけるべきです。

Slide 38

Slide 38 text

ノート：畳み込みパターン代数的データ型 A について、畳み込みはそれを総称型 B に変換する。畳み込みは下記を伴う構造的再帰である。 ● A の各ケースについてひとつの関数引数 ● 各関数はその関連するクラスのフィールドを引数としてとる ● A が再帰的な場合、再帰的フィールドを参照するどの関数引数も型 B の引数をとるマッチするケースのパターンの右辺側、ないしは適切な多相メソッドは、適切な関数呼び出しで構成される。 38

Slide 39

Slide 39 text

5.3.1 畳み込みパターンを適用して fold メソッドを引き出してみましょう。基本的なテンプレートからスタートしてみます。 sealed trait LinkedList[A] { def fold[B](???): B = this match { case End() => ??? case Pair(hd, tl) => ??? } } final case class Pair[A](head: A, tail: LinkedList[A]) extends LinkedList[A] final case class End[A]() extends LinkedList[A] これは結果型として総称型引数を追加した構造的再帰のテンプレートです。

Slide 40

Slide 40 text

5.3.1 畳み込み LinkedList の2つのクラスそれぞれに対応する関数を追加します。 def fold[B](end: ???, pair: ???): B = this match { case End() => ??? case Pair(hd, tl) => ??? }

Slide 41

Slide 41 text

5.3.1 畳み込み関数型についての規則から次のように決定できます。 End は値を保持しないので end は無引数で B を返します。よってその型は () => B で、単に型 B の値として最適化できます。 Pair は2引数を持ち、ひとつはリストの先頭で、もうひとつはリストの末尾です。head についての引数は型 A で、tail についての引数は再帰のなので型 B です。よって最終的に型は (A, B) => B です。 def fold[B](end: B, pair: (A, B) => B): B = this match { case End() => end case Pair(hd, tl) => pair(hd, tl.fold(end, pair)) }

Slide 42

Slide 42 text

5.3.2 関数で作業する Scala には、高階関数として知られる、関数を受け入れる関数やメソッドで作業するための芸当があります。ここから見ていくのは下記のものです。 1. 関数を書くための簡潔な文法 2. メソッドから関数への変換 3. 型推論を活用した高階メソッドの書き方

Slide 43

Slide 43 text

5.3.2.1 プレイスホルダー文法とても単純な状況ではプレイスホルダー文法と呼ばれる簡略文法を使用することでインライン関数を書けます。 ((_: Int) * 2) // res: Int => Int = (_: Int) * 2 はコンパイラーによって (a: Int) => a * 2 に展開されます。慣用的には、コンパイラーが型を推論できる場合にのみ、プレイスホルダー文法を使用します。

Slide 44

Slide 44 text

No content

Slide 45

Slide 45 text

5.3.2.1 プレイスホルダー文法さらにいくつかの例を見てみましょう。 _ + _ // (a, b) => a + b foo(_) // (a) => foo(a) foo(_, b) // (a) => foo(a, b) _(foo) // (a) => a(foo) プレイスホルダー文法は、大きな式において使用すると理解しづらくなるため、とても小さな関数においてのみ使用すべきです。

Slide 46

Slide 46 text

5.3.3 メソッドから関数への変換 * Scala はメソッドコールを関数に変換する機能を含みます。この機能はプレイスホルダー文法と関連しており、アンダースコアをメソッドの末尾に付与します。 object Sum { def sum(x: Int, y: Int) = x + y } Sum.sum // :9: error: missing arguments for method sum in object Sum; // follow this method with `_' if you want to treat it as a ... // Sum.sum // ^ (Sum.sum _) // res: (Int, Int) => Int = * 訳注：節番号が 5.3.2.2 になる内容です。おそらく誤植と考えられます。

Slide 47

Slide 47 text

No content

Slide 48

Slide 48 text

5.3.3 メソッドから関数への変換 Scala は関数が必要なところと推論し、アンダースコアを省略してメソッド名だけを記述できます。コンパイラーは自動的にメソッドを関数に昇格させます。 object MathStuff { def add1(num: Int) = num + 1 } Counter(2).adjust(MathStuff.add1) // res: Counter = Counter(3)

Slide 49

Slide 49 text

No content

Slide 50

Slide 50 text

5.3.3.1 複数引数列 * Scala のメソッドは複数の引数列を持てます。それらのメソッドは、各引数列を括弧で囲む必要があることを除いて、普通のメソッドのように動作します。 def example(x: Int)(y: Int) = x + y // example: (x: Int)(y: Int)Int example(1)(2) // res: Int = 3 * 訳注：節番号が 5.3.2.3 になる内容です。おそらく誤植と考えられます。

Slide 51

Slide 51 text

No content

Slide 52

Slide 52 text

5.3.3.1 複数引数列複数引数列は2つの利用目的があります。1つ目は、コードブロックのように関数を記述する機能のためです。 def fold[B](end: B)(pair: (A, B) => B): B = this match { case End() => end case Pair(hd, tl) => pair(hd, tl.fold(end, pair)) } これによって下記のように呼び出すことができます。 fold(0){ (total, elt) => total + elt } 下記よりは読み易くなります。 fold(0, (total, elt) => total + elt)

Slide 53

Slide 53 text

5.3.3.1 複数引数列 2つ目は、型推論を容易にするためです。Scala の型推論アルゴリズムは、ある引数の型推論結果をほかの引数に利用できません。下記のような宣言では、Scala が end について B を推論しても、pair で B の型推論に利用できないので、pair に型宣言を書く必要があります。 def fold[B](end: B, pair: (A, B) => B): B しかし、Scala はある引数列での型推論を、ほかの引数列での型推論に利用できます。そのため、下記のように記述することで、end の B についての型推論を pair 型の推論に利用できます。 def fold[B](end: B)(pair: (A, B) => B): B

Slide 54

Slide 54 text

No content

Slide 55

Slide 55 text

5.4 総称型によるデータモデリング本節では、データモデリングのときに利用できる総称型の追加機能を見ていきます。総称直和型と総称直積型として実装される総称型と、任意値のように便利な抽象のモデルをいくつか見ます。

Slide 56

Slide 56 text

5.4.1 総称直積型直積型をモデリングするために総称を使用してみましょう。2値を返すメソッドについて考えてみます。 def intAndString: ??? = // ... def booleanAndDouble: ??? = // ...

Slide 57

Slide 57 text

5.4.1 総称直積型問題は返却型として何を使うべきかということです。型引数を持たない代数的データ型パターンのクラスを使用できますが、返却型の組み合わせごとにひとつのクラスを実装しなければなりません。 case class IntAndString(intValue: Int, stringValue: String) def intAndString: IntAndString = // ... case class BooleanAndDouble(booleanValue: Boolean, doubleValue: Double) def booleanAndDouble: BooleanAndDouble = // ...

Slide 58

Slide 58 text

5.4.1 総称直積型 Pair などが直積型を総称を使用して生成するもので、両方の返却型についての関連するデータを含みます。 def intAndString: Pair[Int, String] = // … def booleanAndDouble: Pair[Boolean, Double] = // … 総称は、直積型を定義するための異なる手法を提供し、継承と反対で集約に依拠しています。

Slide 59

Slide 59 text

No content

Slide 60

Slide 60 text

5.4.2 タプルタプルはペアの一般化です。Scala には22要素までの組み込みの総称タプル型があり、それらを生成するための特別な文法があります。そのクラスは Tuple1[A] から Tupple22[A, B, C, ...] ですが、糖衣構文で (A, B, C, ...) と記述することができます。 Tuple2("hi", 1) // res: (String, Int) = (hi,1) ("hi", 1) // res: (String, Int) = (hi,1) ("hi", 1, true) // res: (String, Int, Boolean) = (hi,1,true)

Slide 61

Slide 61 text

No content

Slide 62

Slide 62 text

5.4.2 タプル引数としてタプルを受け取るメソッドを同じ文法を使用して定義できます。 def tuplized[A, B](in: (A, B)) = in._1 // tuplized: [A, B](in: (A, B))A tuplized(("a", 1)) // res: String = a

Slide 63

Slide 63 text

No content

Slide 64

Slide 64 text

5.4.2 タプル下記のようにタプルでパターンマッチすることもできます。 (1, "a") match { case (a, b) => a + b } // res: String = 1a

Slide 65

Slide 65 text

No content

Slide 66

Slide 66 text

5.4.2 タプルまた、パターンマッチはタプルを分解する自然な方法で、各クラスは _1 や _2 などと名付けられたフィールドを持ちます。 val x = (1, "b", true) // x: (Int, String, Boolean) = (1,b,true) x._1 // res: Int = 1 x._3 // res: Boolean = true

Slide 67

Slide 67 text

No content

Slide 68

Slide 68 text

5.4.3 総称直和型直和型をモデリングするために総称を使用してみましょう。まえに、代数的データ型パターンを使用して実装し、共通属性を基底型に含めました。このパターンと異なる抽象を総称は実現し、一般化した実装を提供します。そのメソッドについて考えると、その引数の値に依存し、2つの型のうち1つを返します。 def intOrString(input: Boolean) = if (input == true) 123 else "abc" // intOrString: (input: Boolean)Any

Slide 69

Slide 69 text

5.4.3 総称直和型前述のメソッドは、コンパイラーが Any として結果型を推論してしまうので、安易に書くわけにはいきません。その代わり、選言を明示的に表現するために新しい型を導入します。 def intOrString(input: Boolean): Sum[Int, String] = if(input == true) { Left[Int, String](123) } else { Right[Int, String]("abc") }

Slide 70

Slide 70 text

No content

Slide 71

Slide 71 text

5.4.4 総称任意値式は値を生成することもあれば、生成しないこともあります。例えば、キーによってハッシュテーブルの要素を参照するとき、値が存在しないことがあります。Web サービスと通信している場合、サービスが停止していて返信がないかもしれません。また、ファイルを参照する場合、そのファイルは削除されてしまっているかもしれません。任意値を使用してこのような状況をモデリングする方法がいくつかあります。値が存在しないときに、例外を投げたり、null を返したりします。この2つの方法が持つ欠点は型システムについてのどんな情報も含まないということです。一般に堅牢なプログラムを書きたいもので、Scala では型システムを活用して、プログラムを保守するための特質を表現します。ある共通の特質は「エラーを正しく処理する」というものです。型システムで任意値を表現する場合、コンパイラーは値が存在しない場合を考えることを強制するので、コードの堅牢性が増大します。

Slide 72

Slide 72 text

No content

Slide 73

Slide 73 text

5.4.5 キーポイント：総称型によるデータモデリング本節では直積型と直和型をモデリングするために総称を使用しました。それらの抽象は Scala コードで普通に使用され、Scala の標準ライブラリの実装に含まれます。直積型はタプルで、直和型は Either で、任意値は Option でモデリングされます。

Slide 74

Slide 74 text

5.5 シーケンス処理総称データと代数的データ型の畳み込みを修得しました。さて、処理におけるいくつか他の共通パターンを見ていきましょう。1つ目、場合によっては代数的データ型について畳み込みするよりも便利なものです。2つ目、畳み込みできないあるデータのタイプについて実装を可能にするものです。それらのメソッドは Map と FlatMap として知られています。

Slide 75

Slide 75 text

5.5.1 マップ (Map) 下記の例は、共通に型 F[A] と関数 A => B を持ち、結果 F[B] を得ます。この処理を実行するメソッドはマップと呼ばれます。 ● 「ユーザー ID のリスト」「ユーザー ID からユーザーレコードを取得する関数」を持つ。ID のリストからレコードのリストを取得したい。型として書くと、List[Int] と関数 Int => User を持ち、List[User] を取得したい。 ● 「データベースから読み込まれたユーザーレコードを表現する任意値」「注文を読み込む関数」を持つ。レコードがある場合、注文を取得したい。Maybe[User] と関数 User => Order を持ち、Maybe[Order] を取得したい。 ● 「エラーメッセージか注文を表現する直和型」を持つ。注文がある場合、注文の合計値を取得したい。Sum[String, Order] と関数 Order => Double を持ち、 Sum[String, Double] を取得したい。

Slide 76

Slide 76 text

5.5.1 マップ (Map) LinkedList におけるマップを実装してみます。型と一般的な構造的再帰のスケルトンを与えるところから始めます。 sealed trait LinkedList[A] { def map[B](fn: A => B): LinkedList[B] = this match { case Pair(hd, tl) => ??? case End() => ??? } } final case class Pair[A](head: A, tail: LinkedList[A]) extends LinkedList[A] final case class End[A]() extends LinkedList[A]

Slide 77

Slide 77 text

No content

Slide 78

Slide 78 text

5.5.1 マップ (Map) 代数的データ型における普遍的なイテレーターである畳み込みを構造的再帰パターンとして使用します。

Slide 79

Slide 79 text

5.5.1 マップ (Map) Pair は、先頭と末尾を組み合わせて LinkedList[B] を返します。また、末尾は再帰する必要があります。 case Pair(hd, tl) => { val newTail: LinkedList[B] = tl.map(fn) // Combine newTail and head to create LinkedList[B] } fn 関数を使用して先頭を B に変換し、末尾を再帰したリストから大きなリストを構築します。 case Pair(hd, tl) => Pair(fn(hd), tl.map(fn))

Slide 80

Slide 80 text

5.5.1 マップ (Map) End は、関数を適用できる A の値を持ちません。End を返すだけです。 sealed trait LinkedList[A] { def map[B](fn: A => B): LinkedList[B] = this match { case Pair(hd, tl) => Pair(fn(hd), tl.map(fn)) case End() => End[B]() } } 型とパターンが解決に導いてくれていることに気付きますよね。

Slide 81

Slide 81 text

No content

Slide 82

Slide 82 text

5.5.2 フラットマップ (FlatMap) 下記の例を想像してください。 ● 「ユーザーのリスト」を持ち、すべてのユーザーの注文のリストを取得したい。型として書くと、LinkedList[User] と関数 User => LinkedList[Order] を持ち、 LinkedList[Order] を取得したい。 ● 「データベースから読み込まれたユーザーレコードを表現する任意値」を持ち、別の任意値として最新の注文を取得したい。型として書くと、Maybe[User] と関数 User => Maybe[Order] を持ち、Maybe[Order] を取得したい。 ● 「エラーメッセージか注文を表現する直和型」を持ち、ユーザーに請求書をメール送信したい。メールはエラーメッセージかメッセージ ID を返す。型として書くと、 Sum[String, Order] と関数 Order => Sum[String, Id] を持ち、Sum[String, Id] を取得したい。

Slide 83

Slide 83 text

5.5.2 フラットマップ (FlatMap) すべての例は共通に型 F[A] と関数 A => F[B] を持ち、結果 F[B] を取得したいことになります。この処理を実行するメソッドを flatMap と呼びます。 Maybe について flatMap を実装してみましょう。まずは型を下書きするところから始めます。 sealed trait Maybe[A] { def flatMap[B](fn: A => Maybe[B]): Maybe[B] = ??? } final case class Full[A](value: A) extends Maybe[A] final case class Empty[A]() extends Maybe[A]

Slide 84

Slide 84 text

No content

Slide 85

Slide 85 text

5.5.2 フラットマップ (FlatMap) メソッド本体を埋めるために、前と同じパターン、構造的再帰と型の導きを使用します。 sealed trait Maybe[A] { def flatMap[B](fn: A => Maybe[B]): Maybe[B] = this match { case Full(v) => fn(v) case Empty() => Empty[B]() } } final case class Full[A](value: A) extends Maybe[A] final case class Empty[A]() extends Maybe[A]

Slide 86

Slide 86 text

No content

Slide 87

Slide 87 text

5.5.3 関手 (Functor) とモナド (Monad) map メソッドを持つ F[A] のような型を関手と呼びます。さらに flatMap メソッドをも持つ場合はモナドと呼びます。関手やモナドであるためにはもう少し必要なものがあります。モナドについては、point と呼ばれるコンストラクターと、map や flatMap が必ず従わなければならない代数的規則が必要です。モナドについての情報はオンラインで見付けることもできますし、 Advanced Scala でより詳細について解説しています。

Slide 88

Slide 88 text

5.5.3 関手 (Functor) とモナド (Monad) もっとも、map や flatMap の目下における応用はリストのようなコレクションクラスで、大局的な見地としてはシーケンス処理です。失敗を含む処理の並びを想像してみてください。 def mightFail1: Maybe[Int] = Full(1) def mightFail2: Maybe[Int] = Full(2) def mightFail3: Maybe[Int] = Empty[Int] // これが失敗になる

Slide 89

Slide 89 text

No content

Slide 90

Slide 90 text

5.5.3 関手 (Functor) とモナド (Monad) 別の処理の後にある処理を実行したいです。それらのうちひとつでも失敗した場合、すべての処理は失敗します。そうでない場合、すべての数を足し上げたものを取得します。これを flatMap で実現できます。下記の結果は Empty になります。 mightFail1 flatMap { x => mightFail2 flatMap { y => mightFail3 flatMap { z => Full(x + y + z) } } }

Slide 91

Slide 91 text

No content

Slide 92

Slide 92 text

5.5.3 関手 (Functor) とモナド (Monad) mightFail3 を取り除いた下記の結果は Full(3) になります。 mightFail1 flatMap { x => mightFail2 flatMap { y => Full(x + y) } }

Slide 93

Slide 93 text

No content

Slide 94

Slide 94 text

5.5.3 関手 (Functor) とモナド (Monad) モナドはある文脈における値を表現します。文脈は使用しているモナドに依存します。 ● 任意値。例えば、データベースから取得する値を表現する ● 直和値。例えば、エラーメッセージか計算値を表現する ● 値のリスト同じ文脈を維持したまま、文脈に含まれる値を新しい値に変換するとき map を使用します。値を変換し新しい文脈を与えるとき flatMap を使用します。

Slide 95

Slide 95 text

5.6 変位本節では、型の間における派生クラス関係の制御を型引数によって可能にする変位注釈について説明します。非変総称直和型パターンを改めて見てみましょう。 sealed trait Maybe[A] final case class Full[A](value: A) extends Maybe[A] final case class Empty[A]() extends Maybe[A] 理想的には Empty の使用されていない型引数を下記のように取り除きたいです。 sealed trait Maybe[A] final case class Full[A](value: A) extends Maybe[A] final case object Empty extends Maybe[???]

Slide 96

Slide 96 text

5.6 変位オブジェクトは型引数を持ちません。Empty オブジェクトを作成するためにはその定義より Maybe を拡張した具象型を与える必要があります。しかし、どの型引数を使用すべきでしょうか？特定のデータ型が与えられない場合、Unit や Nothing のようなものを使用しますが、これは型エラーを引き起こします。 val possible: Maybe[Int] = Empty // :9: error: type mismatch; // found : Empty.type // required: Maybe[Int] // val possible: Maybe[Int] = Empty Empty は Maybe[Nothing] であり、Maybe[Nothing] は Maybe[Int] の派生型ではないことが問題です。この問題を克服するために変位注釈を使用します。

Slide 97

Slide 97 text

No content

Slide 98

Slide 98 text

ノート：変位は難しい変位は Scala 型システムの巧妙な側面のひとつです。アプリケーションコードで使用することがめったにないとしても、それが存在していることを認識していることは有用です。 98

Slide 99

Slide 99 text

5.6.1 非変・共変・反変型 Foo[A] を持ち、A は B の派生型である場合、Foo[A] は Foo[B] の派生型でしょうか？この答えは型 Foo の変位に依存します。総称型の変位は、その型引数による基底型と派生型の関係を決定します。型 Foo[T] は T の観点で非変で、A と B の関係に関わらず、Foo[A] と Foo[B] は無関係です。Scala のどんな総称型においてもデフォルトの変位です。型 Foo[+T] は T の観点で共変で、A が B の派生型である場合、Foo[A] は Foo[B] の派生型です。ほとんどの Scala コレクションクラスはそれらの内容の観点で共変です。型 Foo[-T] は T の観点で反変で、A が B の派生型である場合、Foo[A] は Foo[B] の基底型です。反変の唯一の例は関数引数です。

Slide 100

Slide 100 text

5.6.2 関数型関数型について話したときその具体的な実装に立ち入りませんでした。Scala は、0引数から22引数までの関数について、23のビルトイン総称クラスを持ちます。 trait Function0[+R] { def apply: R } trait Function1[-A, +B] { def apply(a: A): B } trait Function2[-A, -B, +C] { def apply(a: A, b: B): C } // and so on...

Slide 101

Slide 101 text

5.6.2 関数型関数は、それらの引数の観点で反変で、それらの返却型の観点で共変です。これは直感に反しますが、関数引数の視点から見ることで理解できるはずです。Function1[A, B] を期待するコードについて検討してみましょう。 class Box[A](value: A) { /** value に func を適用し、結果の Box を返す。 */ def map[B](func: Function1[A, B]): Box[B] = Box(func(a)) }

Slide 102

Slide 102 text

5.6.2 関数型変位を理解するには、どんな関数を map メソッドに安全に渡せるか検討します。 ● A から B への関数は明らかに OK である。 ● A から B の派生型への関数は OK である。なぜなら、その結果型は B の属性すべてを持っているためだ。これは、結果型において共変である関数を示している。 ● A の基底型から B への関数も OK である。なぜなら、Box が持つ A は関数が期待する属性すべてを持っているためだ。 ● A の派生型から B への関数は OK ではない。なぜなら、値は A の派生型とはおそらく異なるためだ。

Slide 103

Slide 103 text

5.6.3 共変直和型変位注釈について理解したので、Maybe 問題を共変にすることで解決できます。 sealed trait Maybe[+A] final case class Full[A](value: A) extends Maybe[A] final case object Empty extends Maybe[Nothing] 使用してみると期待する動作を得られます。Empty はすべての Full 値の派生型になります。 val perhaps: Maybe[Int] = Empty // perhaps: Maybe[Int] = Empty このパターンは総称直和型で頻繁に使用されます。共変型は、コンテナー型が不変であるときのみ使用すべきです。コンテナーが可変である場合、非変型のみ使用すべきです。

Slide 104

Slide 104 text

No content

Slide 105

Slide 105 text

ノート：共変総称直和型パターン型 T の A が B か C であり、C が総称でない場合、このように記述する。 sealed trait A[+T] final case class B[T](t: T) extends A[T] final case object C extends A[Nothing] このパターンはひとつ以上の型引数を拡張する。直和型の特定ケースで型引数が必要とされない場合、その型引数を Nothing で置換できる。 105

Slide 106

Slide 106 text

5.6.4 反変ポジション共変直和型について学ぶ必要があるほかのパターンとして、共変型引数の相互作用と、反変なメソッドと関数引数があります。共変の Sum を実装することでその問題を明らかにしましょう。 sealed trait Sum[+A, +B] { def flatMap[C](f: B => Sum[A, C]): Sum[A, C] = this match { case Failure(v) => Failure(v) case Success(v) => f(v) } } final case class Failure[A](value: A) extends Sum[A, Nothing] final case class Success[B](value: B) extends Sum[Nothing, B]

Slide 107

Slide 107 text

No content

Slide 108

Slide 108 text

5.6.4 反変ポジションこの問題をより単純な例で考えてみましょう。 case class Box[+A](value: A) { def set(a: A): Box[A] = Box(a) } // :12: error: covariant type A occurs in ... // def set(a: A): Box[A] = Box(a) // ^

Slide 109

Slide 109 text

5.6.4 反変ポジション関数やメソッドにおける引数は反変であることを思い出してください。このケースでは、A は共変であると指定していますが、型 A の引数を持つので、型規則は A が反変であることを求めています。このためコンパイラーが「反変ポジション」と伝えているのです。 A の基底型である新しい型を導入することが解決になります。これを [AA >: A] という記法で実現できます。 case class Box[+A](value: A) { def set[AA >: A](a: AA): Box[AA] = Box(a) }

Slide 110

Slide 110 text

No content

Slide 111

Slide 111 text

5.6.4 反変ポジション flatMap に戻ると、関数 f は引数なので反変ポジションです。f の基底型を受け入れられるということになります。型 B => Sum[A, C] と宣言でき、基底型は B について共変で、 A と C について反変です。B は共変として宣言されているので問題ありません。C は非変なので問題ありません。一方、反変ポジションにおいて A は共変になっています。よって Box で使用した解法を適用します。 sealed trait Sum[+A, +B] { def flatMap[AA >: A, C](f: B => Sum[AA, C]): Sum[AA, C] = this match { case Failure(v) => Failure(v) case Success(v) => f(v) } } final case class Failure[A](value: A) extends Sum[A, Nothing] final case class Success[B](value: B) extends Sum[Nothing, B]

Slide 112

Slide 112 text

ノート：反変ポジションパターン共変型 T の A があり、A のメソッド f において T が反変ポジションで使用されていると警告される場合、f において型 TT >: T を導入する。 case class A[+T] { def f[TT >: T](t: TT): A[TT] } 112

Slide 113

Slide 113 text

5.6.5 型境界反変ポジションパターンにおいて型境界を見てきました。型境界は指定の派生型や基底型を拡張します。A <: Type は A が Type の派生型でなければならないことを宣言し、 A >: Type は A が Type の基底型でなければならないことを宣言する文法です。下記の例は Visitor かその派生型を保持することを可能にします。 case class WebAnalytics[A <: Visitor]( visitor: A, pageViews: Int, searchTerms: List[String], isOrganic: Boolean )

Slide 114

Slide 114 text

5.7 まとめ本章では、型とメソッドを抽象化する総称型と関数を探究しました。総称代数的データ型における新しいパターンと総称構造的再帰を見ました。それらのビルディングブロックを使用することで、総称型を扱うためのいくつかの共通パターン、 fold・map・flatMap を見ました。次章では、さらに Scala のコレクションクラスで作業する話題を探究します。