Essential Scala 第4章トレイトによるデータモデリング / Essential Scala Chapter 4 Modelling Data with Traits

Slide 1

Slide 1 text

Essential Scala 第4章トレイトによるデータモデリング 2018.8.1 Takuya Tsuchida (@takuya0301)

Slide 2

Slide 2 text

第4章トレイトによるデータモデリング 4.1 トレイト 4.2 あれかこれかで他にはない：シールドトレイト 4.3 トレイトによるデータモデリング 4.4 直和型パターン 4.5 データで作業する 4.6 再帰的データ 4.7 大きな例 4.8 まとめ 2

Slide 3

Slide 3 text

第4章トレイトによるデータモデリング前章でクラスの奥深さを見ました。クラスは類似した属性を持つオブジェクトを抽象化する方法を提供し、クラスに属するどんなオブジェクトでも動作するコードを書けるようになりました。本章ではクラスを抽象化する方法を探検し、異なるクラスのオブジェクトでも動作するコードを書きます。これをトレイトと呼ばれるメカニズムで実現します。本章は視点の変更を示します。前章では Scala コードを構成する技術的側面を重視してきました。本章のはじめでもトレイトの技術的側面を重視します。その視点は、思考を表現する媒体として Scala を使用することに変化していきます。代数的データ型と呼ばれるデータの記述をコードに機械的に変換する方法を見ていきます。構造的再帰を使用することで、代数的データ型を変換するコードを機械的に記述できます。 3

Slide 4

Slide 4 text

4.1 トレイトトレイトはクラス作成のためのテンプレートで、クラスがオブジェクト作成のテンプレートであるのと同様です。トレイトは2つ以上のクラスを同じと見なす表現で、いずれも同じ操作を実装します。言い換えると、トレイトは共通の基底型を共有する複数のクラスを表現します。 4

Slide 5

Slide 5 text

ノート：トレイト対 Java インターフェイストレイトはデフォルトメソッドを伴う Java 8 のインターフェイスにとても似ている。Java 8 を使用したことがないのであれば、インターフェイスと抽象クラスを掛け合わせたものがトレイトであると考えていい。 5

Slide 6

Slide 6 text

4.1.1 トレイトの例トレイトの例からはじめます。Web サイトの訪問者をモデリングすることを想像します。訪問者には2つの型、サイトに登録済みと匿名があります。 case class Anonymous( id: String, createdAt: Date = new Date() ) case class User( id: String, email: String, createdAt: Date = new Date() )

Slide 7

Slide 7 text

No content

Slide 8

Slide 8 text

4.1.1 トレイトの例そこには明白な重複がありますが、同じ定義を2回書かない方がいいでしょう。より重要ことは、2種類の訪問者に共通する型をつくることです。共通の型を持たせることができれば、どの種類の訪問者でも動作するメソッドを書くことができます。これをトレイトで実現します。 trait Visitor { def id: String // 各ユーザーに付与されるユニークな ID def createdAt: Date // このユーザーがサイトにはじめて訪れた日付 // 訪問者がどのくらいの時間そこにいたか？ def age: Long = new Date().getTime - createdAt.getTime }

Slide 9

Slide 9 text

4.1.1 トレイトの例 case class Anonymous( id: String, createdAt: Date = new Date() ) extends Visitor case class User( id: String, email: String, createdAt: Date = new Date() ) extends Visitor

Slide 10

Slide 10 text

No content

Slide 11

Slide 11 text

4.1.1 トレイトの例下記の2つについて変更しています。 ● Visitor トレイトを定義する ● extends キーワードを使用し Visitor トレイトの派生型として Anonymous と User を宣言する Visitor トレイトは、どんな派生型でも必ず実装しなければならないインターフェイスを表現します。派生型は id と呼ばれる文字列と日付の createdAt を必ず実装します。また、どんな Visitor の派生型でも Visitor に定義されている age メソッドを自動的に持ちます。

Slide 12

Slide 12 text

4.1.1 トレイトの例 Visitor トレイトを定義することによって、どんな訪問者の派生型についても動作するメソッドを書くことができます。 def older(v1: Visitor, v2: Visitor): Boolean = v1.createdAt.before(v2.createdAt) older(Anonymous("1"), User("2", "[email protected]")) // res4: Boolean = true older メソッドは Visitor の派生型である Anonymous でも User でも呼び出すことができます。

Slide 13

Slide 13 text

No content

Slide 14

Slide 14 text

ノート：トレイト文法トレイトは下記のように宣言できる。 trait TraitName { declarationOrExpression ... } トレイトの派生型であるクラスやケースクラスは下記のように宣言できる。 class Name(...) extends TraitName { ... } case class Name(...) extends TraitName { ... } 14

Slide 15

Slide 15 text

4.1.2 トレイトとクラスの比較クラスのように、トレイトはフィールド定義とメソッド定義の名付けられた集合です。しかし、下記の点でクラスとは違います。トレイトはコンストラクターを持てません。トレイトからは直接オブジェクトを生成できません。その代わりにクラスを生成するためにトレイトを使用し、そのクラスからオブジェクトを生成します。トレイトは名前と型を持ち実装を持たない抽象メソッドを定義できます。これを Visitor トレイトで見ました。トレイトを拡張したクラスを生成するときには実装を指定する必要がありますが、それまでは定義を抽象なままにしておいてかまいません。

Slide 16

Slide 16 text

4.1.2 トレイトとクラスの比較抽象的な定義を探すために Visitor トレイトに立ち返ってみましょう。 trait Visitor { def id: String // 各ユーザーに付与されるユニークな ID def createdAt: Date // このユーザーがサイトにはじめて訪れた日付 // 訪問者がどのくらいの時間そこにいたか？ def age: Long = new Date().getTime - createdAt.getTime } Visitor は2つの抽象メソッドを規定しています。メソッドは実装を持ちませんが、派生クラスで実装されなければなりません。その対象として id と createdAt があります。また、ひとつの抽象メソッドを項として定義に含む、具象メソッドである age を定義しています。

Slide 17

Slide 17 text

4.1.2 トレイトとクラスの比較 Visitor は Anonymous と User という2つのクラスのためのビルディングブロックとして使用されています。各クラスは Visitor を拡張しており、それはそのフィールドとメソッドのすべてを継承していることを意味します。 Anonymous("anon1") // res14: Anonymous = Anonymous(anon1) res14.createdAt // res15: java.util.Date = Mon Mar 24 15:11:45 GMT 2014 res14.age // res16: Long = 8871

Slide 18

Slide 18 text

4.1.2 トレイトとクラスの比較 id と createdAt は抽象なので、それらは派生クラスで定義される必要があります。例のクラスでは def ではなく val として実装しています。Scala ではこれが認められており、 val を一般化したものが def であると見なされます * 。トレイトの中で val を定義せずに def を使用することはいいことです。具体的な実装は適切に def か val を使用して実装しましょう。 * オブジェクトリテラルについての課題で見た統一形式アクセスの原則のことです。

Slide 19

Slide 19 text

4.1.3 キーポイント：トレイトトレイトは、オブジェクトを抽象化する方法としてのクラスのように、類似した属性を持つクラスを抽象化する方法です。トレイトと、トレイトを継承したクラス（普通はケースクラス）を宣言することで使用します。 trait TraitName { declarationOrExpression ... } case class Name(...) extends TraitName { ... }

Slide 20

Slide 20 text

4.2 あれかこれかで他にはない：シールドトレイト多くの場合に、トレイトを拡張することが考えうるすべてのクラスを列挙できます。例えば、Web サイトの訪問者を Anonymous かログイン済みの User としてモデリングしました。それら2つのケースは可能なもののすべてを含むので、一方のケースの反対は他方のケースになります。これはシールドトレイトでモデリングでき、コンパイラーが追加の検査を提供してくれます。

Slide 21

Slide 21 text

4.2 あれかこれかで他にはない：シールドトレイトシールドトレイトはトレイト宣言に sealed と記述するだけで作成できます。 sealed trait Visitor { def id: String def createdAt: Date def age: Long = new Date().getTime() - createdAt.getTime() } case class User(id: String, email: String, createdAt: Date = new Date()) extends Visitor case class Anonymous(id: String, createdAt: Date = new Date()) extends Visitor

Slide 22

Slide 22 text

No content

Slide 23

Slide 23 text

4.2 あれかこれかで他にはない：シールドトレイトシールドとしてトレイトをマークしたときは、同じファイルですべての派生型を定義しなければなりません。ひとたびトレイトがシールドになると、コンパイラーは派生型の完全な集合を把握し、パターンマッチ式で不足しているケースがあると警告してくれます。 def missingCase(v: Visitor) = v match { case User(_, _, _) => "Got a user" } // :15: warning: match may not be exhaustive. // It would fail on the following input: Anonymous(_, _) // def missingCase(v: Visitor) = v match { // ^ // missingCase: (v: Visitor)String

Slide 24

Slide 24 text

No content

Slide 25

Slide 25 text

4.2 あれかこれかで他にはない：シールドトレイトシールドトレイトの派生型は、それが定義されているファイル外で拡張できてしまいます。派生型をファイル内での拡張が可能な sealed か final として宣言することで防ぐことができます。 sealed trait Visitor { /* ... */ } final case class User(/* ... */) extends Visitor final case class Anonymous(/* ... */) extends Visitor

Slide 26

Slide 26 text

ノート：シールドトレイト文法トレイトにおけるすべての派生型が既知であればトレイトを封印すべきである。 sealed trait TraitName { ... } 派生型を拡張することがなければ、派生型を final にすることを検討すべきである。 final case class Name(...) extends TraitName { ... } なお、派生型はシールドトレイトと同じファイルで定義されなければならない。 26

Slide 27

Slide 27 text

4.2.1 キーポイント：シールドトレイトシールドトレイトとファイナル（ケース）クラスは型の拡張性を制御できるようにします。大多数はシールドトレイトとファイナルケースクラスのパターンとして使用されます。 sealed trait TraitName { ... } final case class Name(...) extends TraitName このパターンの主な利点は、コンパイラーがパターンマッチで不足している型を警告してくれることと、シールドトレイトを拡張する場所を制御することで派生型の振る舞いを保証できることです。

Slide 28

Slide 28 text

4.3 トレイトによるデータモデリング本節では言語機能からプログラミングパターンに焦点を移していきます。データモデリングについて見ていきながら、論理和と論理積の見地から様々なデータモデルをScala で表現するプロセスを学びます。オブジェクト指向プログラミングの専門用語である is-a 関係と has-a 関係を表現し、関数プログラミングの専門用語である、代数的データ型と呼ばれる直和型と直積型を学びます。本節でのゴールは、どうデータモデルを Scala コードに変換するかを見るということです。次節では代数的データ型を使用したコードのパターンを見ます。

Slide 29

Slide 29 text

4.3.1 直積型パターン最初のパターンは、他のデータを含むデータをモデリングするものです。「A は B と C を持つ」と説明できます。これはケースクラスを使用して記述します。

Slide 30

Slide 30 text

ノート：直積型パターン A が B 型の b と C 型の c を持つ場合、このように記述する。 case class A(b: B, c: C) or trait A { def b: B def c: C } 30

Slide 31

Slide 31 text

4.4 直和型パターン * 次のパターンは、2つ以上の異なったケースになるデータをモデリングするものです。「A は B か C である」と説明できます。これはシールドトレイトとケースクラスのパターンで記述します。 * 訳注：節番号が 4.3.2 になる内容です。おそらく誤植と考えられます。

Slide 32

Slide 32 text

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

Slide 33

Slide 33 text

4.4.1 代数的データ型代数的データ型は、前述の2つのパターンを使用したデータになります。関数プログラミングの文脈では、has-a and パターンは直積型であり、is-a or パターンは直和型です。

Slide 34

Slide 34 text

4.4.2 不足しているパターン is-a / has-a と and / or という2軸の関係性を見てきました。この定義を表にすると4つのセルについて2つのパターンしか見ていません。 2つの不足しているパターンは何でしょうか？ And Or Is-a 直和型 Has-a 直積型

Slide 35

Slide 35 text

4.4.2 不足しているパターン is-a and パターンは「A は B かつ C である」を意味します。このパターンはある点において直和型の逆になり、下記のように実装できます。 trait B trait C trait A extends B with C

Slide 36

Slide 36 text

4.4.2 不足しているパターントレイトはたくさんのトレイトから拡張することができます。しかし、本稿ではこのパターンを使用しません。異なるインターフェイスで構成されるデータを表現する場合、あとから学習する型クラスを使用します。道理に合っている場合には、is-a and パターンを使用することもあります。 ● モジュール性のためにケークパターン * を使用する場合 ● いくつかのクラスを横断して実装を共有するときに、メイントレイトがデフォルト実装を持つことが妥当でない場合 * http://jonasboner.com/2008/10/06/real-world-scala-dependency-injection-di/

Slide 37

Slide 37 text

4.4.2 不足しているパターン has-a or パターンは「A は B か C を持つ」を意味します。これを実装するには2つの方法があります。「A は D を持ち、D は B か C である」と言えます。これを実装するために2つのパターンを機械的に適用することができます。 trait A { def d: D } sealed trait D final case class B() extends D final case class C() extends D

Slide 38

Slide 38 text

4.4.2 不足しているパターンあるいは、「A は D か E である、D は B を持ち、E は C を持つ」と言えます。これも直接的にコードに変換できます。 sealed trait A final case class D(b: B) extends A final case class E(c: C) extends A

Slide 39

Slide 39 text

4.4.3 キーポイント：トレイトによるデータモデリング直積型による has-a and パターンと直和型による is-a or パターンで、データを機械的に Scala コードを変換するのを見ました。このタイプのデータは代数的データ型として知られています。それらのパターンを理解することは理想的な Scala コードを書く上でとても重要です。

Slide 40

Slide 40 text

4.5 データで作業する本節では代数的データ型を使用したパターン、構造的再帰を見ていきます。構造的再帰は代数的データ型を組み立てるプロセスのちょうど反対です。直和型パターンと直積型パターンは、組み合わせて大きなデータをつくる方法を教えてくれます。構造的再帰は本質的には小さな部品に分割するプロセスです。代数的データ型を構築するためにちょうど2つのパターンがありましたが、構造的再帰を用いて分解するためにも2つのパターンがあります。実際にはそれぞれのパターンについて2つの変種があり、ひとつは典型的なオブジェクト指向スタイルでポリモーフィズムを使用したもので、もうひとつは典型的な関数スタイルでパターンマッチを使用したものです。どちらの使用を選択すべきかのいくつかのルールで本節を締め括ります。

Slide 41

Slide 41 text

4.5.1 ポリモーフィズムを使用した構造的再帰多相ディスパッチもしくはポリモーフィズムはオブジェクト指向技術の基礎をなします。トレイトでメソッドを定義し、トレイトを拡張したクラスで異なる実装を持つ場合、具象インスタンスで実装されたメソッドが呼び出されます。

Slide 42

Slide 42 text

4.5.1 ポリモーフィズムを使用した構造的再帰直和型を使用したシンプルな定義から始めます。 sealed trait A { def foo: String } final case class B() extends A { def foo: String = "It's B!" } final case class C() extends A { def foo: String = "It's C!" }

Slide 43

Slide 43 text

4.5.1 ポリモーフィズムを使用した構造的再帰 val anA: A = B() // anA: A = B() anA.foo // res1: String = It's B! val anA: A = C() // anA: A = C() anA.foo // res2: String = It's C!

Slide 44

Slide 44 text

No content

Slide 45

Slide 45 text

4.5.1 ポリモーフィズムを使用した構造的再帰トレイトで実装を定義することもでき、派生クラスでは override キーワードを使用して実装を変更します。 sealed trait A { def foo: String = "It's A!" } final case class B() extends A { override def foo: String = "It's B!" } final case class C() extends A { override def foo: String = "It's C!" }

Slide 46

Slide 46 text

4.5.1 ポリモーフィズムを使用した構造的再帰 val anA: A = B() // anA: A = B() anA.foo // res1: String = It's B! トレイトでデフォルト実装を提供する場合、すべての派生型で妥当な実装であることを確実にすべきということを覚えておいてください。

Slide 47

Slide 47 text

No content

Slide 48

Slide 48 text

ノート：直積型ポリモーフィズムパターン A が B 型の b と C 型の c を持ち、F 型を返すメソッド f を記述したい場合、シンプルにいつもの方法でメソッドを記述する。 case class A(b: B, c: C) { def f: F = ??? } メソッドの本体で、F 型の結果を構築するために、 b と c とメソッド引数を必ず使用しなければならない。 48

Slide 49

Slide 49 text

ノート：直和型ポリモーフィズムパターン A が B か C であり、F 型を返すメソッド f を記述したい場合、A で f を抽象メソッドとして定義し、B と C で具象実装を提供する。 sealed trait A { def f: F } final case class B() extends A { def f: F = ??? } final case class C() extends A { def f: F = ??? } 49

Slide 50

Slide 50 text

4.5.2 パターンマッチを使用した構造的再帰パターンマッチによる構造的再帰はポリモーフィズムと同じ線に沿って進みます。それぞれの派生型についてのケースをシンプルに持ち、パターンマッチにおける各ケースにおいて興味のあるフィールドを抽出できます。

Slide 51

Slide 51 text

ノート：直積型パターンマッチパターン A が B 型の b と C 型の c を持ち、A を受け入れ F を返すメソッド f を記述したい場合、下記のように記述する。 def f(a: A): F = a match { case A(b, c) => ??? } メソッドの本体で、F 型の結果を構築するために、 b と c を使用する。 51

Slide 52

Slide 52 text

ノート：直和型パターンマッチパターン A が B か C であり、A を受け入れ F を返すメソッド f を記述したい場合、B と C をパターンマッチのケースとして定義する。 def f(a: A): F = a match { case B() => ??? case C() => ??? } 52

Slide 53

Slide 53 text

4.5.3 完全な例：共通 sealed trait Food final case object Antelope extends Food final case object TigerFood extends Food final case object Licorice extends Food final case class CatFood(food: String) extends Food

Slide 54

Slide 54 text

No content

Slide 55

Slide 55 text

4.5.3 完全な例：ポリモーフィズム sealed trait Feline { def dinner: Food } final case class Lion() extends Feline { def dinner: Food = Antelope } final case class Tiger() extends Feline { def dinner: Food = TigerFood } final case class Panther() extends Feline { def dinner: Food = Licorice } final case class Cat(favouriteFood: String) extends Feline { def dinner: Food = CatFood(favouriteFood) }

Slide 56

Slide 56 text

No content

Slide 57

Slide 57 text

4.5.3 完全な例：パターンマッチ（基底トレイト） sealed trait Feline { def dinner: Food = this match { case Lion() => Antelope case Tiger() => TigerFood case Panther() => Licorice case Cat(favouriteFood) => CatFood(favouriteFood) } } final case class Lion() extends Feline final case class Tiger() extends Feline final case class Panther() extends Feline final case class Cat(favouriteFood: String) extends Feline

Slide 58

Slide 58 text

No content

Slide 59

Slide 59 text

4.5.3 完全な例：パターンマッチ（別オブジェクト） sealed trait Feline final case class Lion() extends Feline final case class Tiger() extends Feline final case class Panther() extends Feline final case class Cat(favouriteFood: String) extends Feline object Diner { def dinner(feline: Feline): Food = feline match { case Lion() => Antelope case Tiger() => TigerFood case Panther() => Licorice case Cat(food) => CatFood(food) } }

Slide 60

Slide 60 text

No content

Slide 61

Slide 61 text

4.5.4 使用するパターンの選び方構造的再帰を実装するのに3つの方法があります。 1. ポリモーフィズム 2. 基底トレイトでのパターンマッチ 3. 外部オブジェクトでのパターンマッチ使用するパターンは下記のルールを参考に選んでみてください。 ● 実装がクラス内のフィールドやメソッドだけに依存している → 1 or 2（一般的に重複するコードが少ない2が選ばれる） ● 実装がクラス外のデータに依存している → 3 ● 複数の実装が必要になる → 3

Slide 62

Slide 62 text

4.5.5 「オブジェクト指向」対「関数的拡張性」典型的な関数プログラミングスタイルはパターンマッチを使用し、典型的なオブジェクト指向スタイルはポリモーフィズムを使用します。関数プログラミングスタイルの利点はコンパイラーがより手助けしてくれることです。オブジェクト指向スタイルは、トレイトを拡張することで新しいデータを容易に追加できますが、新しいメソッドを追加するためには既存のコードを変更しなければなりません。関数プログラミングスタイルは、新しいメソッドを容易に追加できますが、新しいデータを追加するためには既存のコードを変更しなければなりません。新しいメソッドを追加する新しいデータを追加するオブジェクト指向既存のコードを変更する既存のコードを変更しない関数プログラミング既存のコードを変更しない既存のコードを変更する

Slide 63

Slide 63 text

4.5.5 「オブジェクト指向」対「関数的拡張性」 Scala はポリモーフィズムとパターンマッチの両方を使用できる柔軟性を持つので、どちらも適切に使用すべきです。しかしながら、コードの意味論について優れた保証を与えるシールドトレイトを一般的に好み、後述する型クラスを使用することでオブジェクト指向スタイルの拡張性を手に入れることができます。

Slide 64

Slide 64 text

4.6 再帰的データとくに代数的データ型は再帰的データの定義によく使用されます。このデータはそれ自身の項によって定義され、サイズを制約しないデータを作成します。ただし、再帰が永遠に続くため、このようには定義できません。 final case class Broken(broken: Broken) 最後を表すベースケースを定義することで妥当な再帰的データを定義できます。 sealed trait IntList final case object End extends IntList final case class Pair(head: Int, tail: IntList) extends IntList Pair(1, Pair(2, Pair(3, End))) // res: Pair = Pair(1,Pair(2,Pair(3,End)))

Slide 65

Slide 65 text

No content

Slide 66

Slide 66 text

4.6 再帰的データ再帰的代数的データ型を処理するために構造的再帰パターンを適用できます。それでは IntList のすべての要素を加算してみましょう。まずは、メソッド定義とテストを記述するところから始めます。 def sum(list: IntList): Int = ??? val example = Pair(1, Pair(2, Pair(3, End))) assert(sum(example) == 6) assert(sum(example.tail) == 5) assert(sum(End) == 0)

Slide 67

Slide 67 text

No content

Slide 68

Slide 68 text

4.6 再帰的データメソッドの本体に構造的再帰パターンを適用してみましょう。 def sum(list: IntList): Int = list match { case End => ??? case Pair(hd, tl) => ??? }

Slide 69

Slide 69 text

No content

Slide 70

Slide 70 text

4.6 再帰的データ End の解答は 0 と決定できます。Pair は Int 型を返す必要があり、tl について再帰呼び出しをする必要があります。 def sum(list: IntList): Int = list match { case End => 0 case Pair(hd, tl) => ??? sum(tl) }

Slide 71

Slide 71 text

4.6 再帰的データ再帰呼び出しは残りのリストの合計返すので、その結果に hd を加算します。 def sum(list: IntList): Int = list match { case End => 0 case Pair(hd, tl) => hd + sum(tl) }

Slide 72

Slide 72 text

No content

Slide 73

Slide 73 text

4.6.1 ベースケースと再帰ケースを理解するベースケースと再帰ケースの本体を与える上で、一般的な指針があります。ベースケースは、一般的にその計算における単位元を返します。例えば、加算の単位元は0で、乗算の単位元は1です。再帰ケースは、正しい結果を返す再帰と仮定し、正しい解答が得られるように実装を追加しました。sum で見たように、再帰呼び出しが残りのリストについて正しい結果を与えることを仮定し、リストの先頭をただ追加しました。

Slide 74

Slide 74 text

ノート：再帰的代数的データ型パターン再帰的代数的データ型を定義するとき、ひとつは再帰的で、もうひとつは再帰的ではない、という2つのケースが少なくとも必要である。ベースケースとして知られるものは再帰的ではない。コードでの一般的なスケルトンは下記のとおりである。 sealed trait RecursiveExample final case class RecursiveCase(recursion: RecursiveExample) extends RecursiveExample final case object BaseCase extends RecursiveExample 74

Slide 75

Slide 75 text

No content

Slide 76

Slide 76 text

ノート：再帰的構造的再帰パターン再帰的代数的データ型で構造的再帰コードを記述するときは下記のような対応をする。 ● データにおいて再帰要素に遭遇するときはいつも、メソッドの再帰的呼び出しを行う ● データにおいてベースケースに遭遇するときはいつも、実行しようとしている計算の単位元を返す 76

Slide 77

Slide 77 text

4.6.2 末尾再帰再帰によって大量のスタック領域を消費してしまうのではないかと心配するかもしれません。Scala は末尾再帰と呼ばれる最適化を適用するため、多くの再帰関数はスタック領域を消費し続けることはありません。末尾呼び出しは、メソッドを呼び出した値をただちに返すメソッド呼び出しです。下記の tailCall は、method1 の結果をただちに返すので末尾呼び出しです。 def method1: Int = 1 def tailCall: Int = method1 下記の notTailCall は、数値を加算をしているため、 method1 の結果をただちに返さないので末尾呼び出しではありません。 def notATailCall: Int = method1 + 2

Slide 78

Slide 78 text

4.6.2 末尾再帰末尾呼び出しはスタック領域を使用しないよう最適化できます。JVM の制約から Scala は自分自身を呼び出す末尾呼び出ししか最適化できません。よって末尾再帰は保守面で重要で、@tailrec アノテーションを使用することでコンパイラーに末尾再帰になっているかをチェックさせることができます。

Slide 79

Slide 79 text

4.6.2 末尾再帰 import scala.annotation.tailrec @tailrec def sum(list: IntList): Int = list match { case End => 0 case Pair(hd, tl) => hd + sum(tl) } // :18: error: could not optimize @tailrec annotated method sum: it ... // def sum(list: IntList): Int = list match { // ^ @tailrec def sum(list: IntList, total: Int = 0): Int = list match { case End => total case Pair(hd, tl) => sum(tl, total + hd) } // sum: (list: IntList, total: Int)Int

Slide 80

Slide 80 text

No content

Slide 81

Slide 81 text

4.6.2 末尾再帰どんな非末尾再帰関数でも、前述の sum で実現したようにアキュムレーターを追加することで末尾再帰版に変換することができます。 Scala で末尾再帰関数を直接書いて処理することはあまりなく、Scala の充実したコレクションライブラリを使用することで末尾再帰で実現したいことのほとんどを実現できます。

Slide 82

Slide 82 text

4.7 大きな例 * 大きなプロジェクトの例です。 1. Calculator 2. JSON 3. Music * 訳注：課題の節なので説明は割愛します。

Slide 83

Slide 83 text

4.8 まとめ本章では重要な視点の変更を行い、言語機能から離れ、言語機能がサポートするプログラミングパターンに目を向けました。これは本稿の残りでも継続します。 2つの重要なパターン、代数的データ型と構造的再帰を探究しました。それらのパターンは、データのメンタルモデルから、まったく機械的な方法による Scala におけるデータの表現と処理に我々を向かわせます。月並みなコードの構造や理解を容易にするだけではなく、コンパイラーが開発や保守を容易にするために共通のエラーを捕捉してくれます。これら2つのツールは、慣用的な関数的コードで一般に使用され、その重要性はどれほど強調してもしすぎることはありません。本章における課題の中で共通のデータ構造を開発しましたが、固定された型のデータしか保持できなく、そのコードは多くの繰り返しが含まれていました。次章では、型とメソッドを超えた抽象化を見ていきながら、シーケンス処理におけるいくつかの重要なコンセプトを紹介します。