#acl alstamber:read,write,revert,delete,admin All:read
<<TableOfContents>>

== なにこれ ==
 * コップ本にだいたい則ってScalaについてまとめたもの。
 * Scala勉強会とかで使いたい。
 * Scala処理系が入っている前提。
 * コップ本19章ぐらいまで読んだのでその辺りまでとりあえずまとめたい(無理か)
  * 13と14章は飛ばしました
  * 18章も飛ばす

== とりあえず触ってみる ==
 * scalaコマンドを実行するとインタプリタが立ち上がる。
{{{#!highlight scala
scala> 1+1
res0: Int = 2
}}}
{{{#!highlight scala
scala> res0 * 5
res1: Int = 10
}}}
 * 出力にはprintlnメソッドを使う。
  * printlnメソッドはUnit型の唯一のメンバである()を返す→Javaのvoidに相当
{{{#!highlight scala
scala> println("Hello, world!")
Hello, world!
}}}

== 変数の定義 ==
{{{#!highlight scala
scala> val msg = "Hello, world!"
msg: String = Hello, world!
}}}
 * 上の定義の時にわざわざ型名(String)って書かなかった
 * 型が明らかなときは型名を書かなくてもいい→'''型推論'''
 * もちろん書いてもいい
  * 変数の後ろにコロンを書いて型名
{{{#!highlight scala
scala> val msg2:String = "Hello, world!"
msg2: String = Hello, world!
}}}

== varとval ==
 * 変数を定義するときにはvarとvalというキーワードが使える
  * varは何度でも変更できる
  * valは一度しか代入できない
{{{#!highlight scala
scala> val msg = "Hello, world!!"
<console>:8: error: reassignment to val
       msg = "Hello, World!!"
}}}

 * varはなるべく使わないほうがいい
  * 変数の値をいつでも変えられるというのは強力だけど、同時にどこで変数の値が変わってしまったのかわかりにくくなる
  * 極力valを使い、どうしてもパフォーマンスなどでvarのほうが良い時だけvarを使う。

== 関数定義 ==
{{{#!highlight scala
def 関数名(引数名:引数型, 引数名:引数型, ...):戻り値型 = 関数の式
}}}
 * 具体的な例
{{{#!highlight scala
def hello(name:String):String = {
  return "Hello! " + name
}
}}}
 * returnは省略できる
  * 最後の式の結果が返される
{{{#!highlight scala
def hello(name:String):String = {
  "Hello! " + name
}
}}}
 * returnを省略して、かつ戻り値の型が明らかなら戻り値の方も省略できる
{{{#!highlight scala
def hello(name:String) = {
  "Hello! " + name
}
}}}
 * 一行ならそもそも中括弧もいらない
{{{#!highlight scala
def hello(name:String) = "Hello! " + name
}}}

== 単独で動くプログラムをつくってみる ==
 * テンプレ
  * 今はおまじないだと思いましょう
  * argsはStringの配列になっていてmainメソッドの引数です。
{{{#!highlight scala
object hoge
  def main(args:Array[String]) = {
    //メインの処理
  }
}
}}}
 * かけたらコンパイルします
{{{
scalac hoge.scala
}}}
 * 実行します
{{{
scala hoge
}}}
 * scalacじゃなくてfscを使うと便利です
  * fscを使うと2回目以降コンパイルが速くなる

== Scalaらしいループ ==
 * argsの中身を順番に表示するプログラムを書いてみる
 * こんなプログラムを書いてみよう
  * scalaでは配列の添字は丸括弧
  * インクリメントの演算子がないのでi += 1で我慢する
  * 行末のセミコロンはいらない
{{{#!highlight scala
var i = 0
while(i < args.length) {
  println(args(i))
  i += 1
}
}}}
 * このプログラムは良くない
  * varがあるから

 * 配列にはforeachメソッドというのが用意されている
  * 関数を引数にとってその関数を配列の要素に対して実行する
{{{#!highlight scala
args.foreach((arg:String) => println(arg))
}}}
 * argの型はStringなのはわかりきってるのでargの型名は省略できる
{{{#!highlight scala
args.foreach(arg => println(arg))
}}}

== 配列 ==
 * 同じ型しか要素にとれない
 * valで宣言しても要素の変更は自由

=== 配列の生成 ===
{{{#!highlight scala
val hoge = Array[String](3)
}}}

=== 配列への代入と参照 ===
{{{#!highlight scala
hoge(2) = "kyoko"
println(hoge(2))
}}}

=== 便利な配列の生成方法 ===
{{{#!highlight scala
val hoge = Array("Akari", "Kyoko", "Yui", "Chinatsu")
}}}

== リスト ==
 * 同じ型しか要素にとれない
 * 要素の変更は(通常)不可能
  * mutableなリストというのが特別に用意してあって、それを使えば良い。もちろん推奨はされない。

=== リストの生成 ===
{{{#!highlight scala
val hoge = List(2, 3, 5, 7)
}}}

=== リストの結合 ===
{{{#!highlight scala
val hoge = List(2, 3)
val fuga = List(5, 7)
val piyo = hoge ::: fuga
}}}

=== リストの先頭に要素を追加 ===
{{{#!highlight scala
val hoge = List(3, 5, 7)
val fuga = 2 :: hoge
}}}
 * これは実は下の糖衣構文になっている。つまりListの::というメソッドを呼び出してる
{{{#!highlight scala
hoge.::(2)
}}}
 * ::や:::のことをconsという

== タプル ==
 * 違う型の要素も持てる
 * 要素の変更は不可能
 * 言語の制約上22個しか要素が持てない

=== タプルを作る ===
{{{#!highlight scala
val hoge = (1, "Kyoko", 2, "Akari")
}}}

=== タプルを使う ===
{{{#!highlight scala
println(hoge._2)  // Kyoko と表示される
}}}
 * タプルの要素番号はHaskellなどの慣習から1番スタートになっている

== クラス ==
 * Scalaはオブジェクト指向言語なのでクラスを持っている
{{{#!highlight scala
class Hoge {
  var hoge = 1 //フィールド
  var fuga = 3 //フィールド

  def myMultiple() = hoge * fuga //メソッド
}
}}}
 * Javaとかと同じようにnewでクラスからオブジェクトを生成できる
{{{#!highlight scala
val a = new Hoge()
}}}
 * オブジェクトをval宣言の変数に代入しても、そのオブジェクトのフィールドがvar宣言されていれば再代入できる
{{{#!highlight scala
a.hoge = 2  // OK
}}}

== メソッド ==
 * メソッドの引数は勝手にvalで定義される
  * 勝手に変えられないようにするため
 * 戻り値がUnitのメソッドは=を省略できる。ただし=を省略すると中括弧を省略できない。
 * メソッドをprivateにするには次のように記述する
{{{#!highlight scala
private def hello() = "Hello, World!"
}}}

== シングルトンオブジェクト ==
 * Scalaは徹底したオブジェクト指向
  * オブジェクトに属していないものの存在なんて許せない！！！！
  * なのでstaticがありません
 * そのかわりにシングルトンオブジェクトというのがある

=== シングルトンオブジェクトの定義 ===
{{{#!highlight scala
object Hoge {
  // あーだこーだ
}}}

=== シングルトンオブジェクトの性質 ===
 * シングルトンオブジェクトはコードが実行されるときに自動的に生成される
 * またあるスコープの中でひとつしかないことが保証される
  * 多分後述
 * 先ほど「単独で動くプログラムをつくってみる」の所でobjectうんたらと書いたのは、プログラム実行開始時にシングルトンオブジェクトを生成させてその中のmainメソッドを実行するというふうにScalaが仕組まれているから。

== コンパニオンクラスとコンパニオンオブジェクト ==
 * シングルトンオブジェクトと同じ名前のクラスを定義するとそれぞれコンパニオンオブジェクトとコンパニオンクラスと呼ばれるようになって、対で扱われるようになる。
 * コンパニオンオブジェクトからはコンパニオンクラスにアクセスすることができる。
 * コンパニオンオブジェクトはシングルトンオブジェクトなので、プログラム実行開始時に勝手に生成される。
 * なのでstatic代わりに使える。

=== コンパニオンオブジェクトの例 ===
 * https://gist.github.com/j5ik2o/1298006

== 基本型 ==
 * Scalaには次のような型がある
  * 数値型
   * Byte
   * Int
   * Long
   * Short
   * Double
   * Float
   * Char
  * String
  * Boolean

== 基本リテラル ==
=== 整数リテラル ===
 * Int, Long, Short, Byte型のリテラル。
 * 10進、8進、16進表記可能。

=== 浮動小数点リテラル ===
 * 10進表記のみ。
 * 指数表記もできる。

=== 文字リテラル ===
 * シングルクォートでUnicode文字を囲んだもの。

=== 文字列リテラル ===
 * 文字列をダブルクォートで囲ったもの。
 * 改行するとそれもそのまま文字列として反映される

=== シンボルリテラル ===
 * シンボルもやはり文字列を表すためのリテラル
 * 次のように表記する
{{{#!highlight scala
`hoge //hogeのシンボルリテラル
}}}
 * 文字列リテラルとの違いは文字列へのシンボルリテラルであれば必ず同じオブジェクトへの参照になっているということ
{{{#!highlight scala
val hoge = "hoge"
val hoge2 = "hoge" //hogeとhoge2は違うオブジェクトになっている

val fuga = `fuga
val fuga2 = `fuga //fugaとfuga2は同じオブジェクト
}}}

=== Booleanリテラル ===
 * TrueとFalseがある

== 演算子 ==
 * 演算子はメソッドです
{{{#!highlight scala
1 + 2
(1).+(2)  // この2つは同じ意味
}}}
 * 演算子の種類はJavaに準ずるので適当にググってね

=== 比較演算子について ===
 * 1つだけ注意を要するのが比較演算子の==
 * Javaではオブジェクトとしての等価性を判定するものだった
{{{#!highlight java
"hoge" == "hoge" //左と右の文字列は同じオブジェクトかも知れないし違うオブジェクトかもしれないから、TrueかもしれないしFalseかもしれない
}}}
 * Scalaでは内部的にJavaのequalsメソッドを呼び出しているので、==はオブジェクトの持っている値そのものの比較になる
{{{#!highlight scala
"hoge" == "hoge" //かならずTrue
}}}

=== 演算子の優先順位について ===
 * Scalaでは演算子の優先順位は演算子の名前で決まっている
  * 演算子は特別な存在ではなく、ただのメソッドだから
  * 例えば*メソッドは+メソッドよりも優先順位が高いとかいう決め方をしている

=== リッチラッパー ===
 * ScalaではJavaの演算子に加えてもっと賢い演算子が使えるようになっている
 * 例えば
{{{#!highlight scala
0 min 5 // min演算子で計算されて結果が0になる
}}}
 * これはリッチラッパーというクラスによって用意されている。ふだん使うぶんにはリッチラッパーという存在を意識せずにそのまま使うことが出来る。

== 制御構造 ==
=== if式 ===
 * if文じゃなくてif「式」です
  * 値を返すから
{{{#!highlight scala
if (条件式) {
  //真の時の式
}else{
  //偽の時の式
}
}}}
 * 条件式が真のときは「真の時の式」の結果が返ってくる
 * 条件式が偽のときは「偽の時の式」の結果が返ってくる
 * 関数定義の時と同じように式が複数あるときは最後の式の結果が返ってくる
 * なので次のように書ける
{{{#!highlight scala
val hoge = "hoge"
println(if (!hoge.isempty) hoge else "default")
}}}

=== while式, do-while式 ===
 * CとかJavaと同じ。
 * こいつらはUnit型を返す
{{{#!highlight scala
var a = x
var b = y
while(a != 0){
  val temp = a
  a = b % a
  b = temp
}
}}}
 * 一応言っておくとwhileを使うような構文はたいていvarを伴うのでうんこ
 * 使わないようにしましょう
 * 再帰を使うのが常道
  * というわけで練習がてら再帰で上のプログラムを書き換えてみましょう

=== for式 ===
 * for式を使いこなすのがScalaマスターへの第一歩です
 * for「式」なのでやっぱり値を返す
  * forが値を返すとはどういうことなのかは下のyieldに関する所を読んでね

==== for式の基本的な使い方 ====
 * コレクションの反復操作
  * コレクションというのは配列とかListとかそのあたり
{{{#!highlight scala
val yuruyuri = List("Kyoko", "Akari", "Yui", "Chinatsu")
for(member <- yuruyuri){
  println(member)
}
}}}
 * 「member <- yuruyuri」の部分をジェネレータと呼ぶ
  * memberはvalになっていて、ループが1巡するごとにyuruyuriから1つ要素を取り出してmemberという変数を新たに初期化しているイメージ
  * memberという変数を生成しているのでジェネレータ

==== Range ====
 * 順番に並んでいる数値に対して処理をしたいとき
{{{#!highlight scala
for(i <- 1 to 10) println(i) //(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)という数列が生成される
for(i <- 1 until 10) println(i) //(1, 2, 3, 4, 5, 6, 7, 8, 9)という数列が生成される
}}}

==== フィルタリング ====
 * for式では取り出す要素に対してif式で条件を追加できる
 * ifはセミコロンで区切って何個でも並べられる
{{{#!highlight scala
val yuruyuri = List("Kyoko", "Akari", "Yui", "Chinatsu")
for(member <- yuruyuri if member.endsWith("i")){
  println(member)
}
}}}

==== 入れ子のfor式 ====
 * <-を複数書くことで入れ子のfor式を1つのfor式でまとめて書くことができる。
{{{#!highlight scala
for(i <- 1 to 9; j <- 1 to 9) println(i*j)
}}}

==== yield ====
 * yieldはfor式の中に記述して使う。
 * 下の例の場合for文が実行されるごとにyield i+1というのが実行される。これが実行されるとi+1の結果がfor文の返り値として返ってくるようになる。for文は繰り返し実行されるのでyieldによって返ってきた戻り値は蓄積されていって新しいコレクションになる。つまりこの結果hogeには(1, 2, 3, 4, 5, 6)という配列が格納されることになる。
{{{#!highlight scala
val hoge = for (i <- 0 to 5) yield i+1
}}}
 * yieldの後ろで関数を呼び出すこともできるし、ブロックを書くこともできる。

=== try-catch-finally ===
 * ScalaではJavaと違って例外をかならずcatchしなくても良い
 * 次のように書きます
{{{#!highlight scala
try{
  //例外が発生しそうな処理を書く
}catch{
    case e: 例外名  => 例外処理
}
}}}
 * catch節での例外名の記述を端折るとすべての例外をcatchする式になります
 * caseは複数並べて複数の例外に対応出来ます
 * tryもcatchもブロック式なので、最後の式の結果が全体の結果として返る
  * 例外が発生しなかったときはtry節の最後の式の結果
  * 例外が発生したときは対応する例外の処理の最後の式の結果
 * finally節には例外の有無にかかわらず行いたい処理を書く
  * finally節に値を返すような処理を書くべきではない
   * tryやcatchで返された値を上書きしてしまう可能性があるから
   * 例外の有無にかかわらず行いたい副作用を伴う処理に限って書くべき

=== match式 ===
 * こいつも強力な式なのだが、とりあえず最も基本的な使い方であるswitch文の代わりとしての使用法を見てみる
{{{#!highlight scala
val yuruyuri = "kyoko"
yuruyuri match {
  case "kyoko" => println("so cute")
  case "akari" => println("who is she?")
  case _ => println("so so") // _ はdefaultに相当
}
}}}
 * match式は式なので次のように書くこともできる
  * 副作用を伴う処理をmatch式の外に出してしまえるのでこっちのほうがいいかも
{{{#!highlight scala
val yuruyuri = "kyoko"
val result = yuruyuri match {
  case "kyoko" => "so cute"
  case "akari" => "who is she?"
  case _ => "so so"
}
println(result)
}}}

== ローカル関数 ==
 * Scalaでは関数の中に関数を定義することができる→ローカル関数
{{{#!highlight scala
def calc(a:Int, b:Int) = {
  def add() = a + b
  def sub() = a - b
  (add, sub)
}
}}}
 * 上のaddとsubという関数はcalc関数の中でしか使用できない
 * ローカル関数からローカル関数の外の変数にアクセスすることは可能

== 関数リテラル ==
 * 「Scalaらしいループ」というところでforeachメソッドを用いた例を示した
  * そこで以下の様な表現があった
{{{#!highlight scala
arg => println(arg)
}}}
 * これはargという引数をとって、println(arg)という処理を実行する関数になっている
 * より関数型っぽく言えばargという引数に対してprintln(arg)というものを返す関数である
 * Scalaではこのように名前の無い関数をその場で生成して使うことができる。これを関数リテラルとか無名関数などと呼ぶ

== 第一級オブジェクトとしての関数リテラル ==
 * 第一級オブジェクトなどというと仰々しいが、要するに関数リテラルは文字列や数値と同じようにScalaでは扱われていますよということ
 * 同じように扱われているので変数に代入できる
{{{#!highlight scala
val hoge = (x:Int) => x+1
println(hoge(10))
}}}

== プレースホルダー ==
 * ある引数が関数リテラルの中で一度しか使われないときは名前を書かずアンダーバーで代用することができる。
{{{#!highlight scala
val yuruyuri = List("Kyoko", "Akari", "Yui", "Chinatsu")
yuruyuri.foreach(println(_))
// yuruyuri.foreach(x => println(x))と同じ
}}}

 * 型を推論できないような書き方をすると怒られる
{{{#!highlight scala
val myadd = _ + _ //エラーが出る
}}}
 * 型を明示すれば良い
{{{#!highlight scala
val myadd = (_:Int) + (_:Int)
println(myadd(2, 3))
}}}
 * アンダーバーで置き換えられるのは1回だけなので、アンダーバーの個数だけ引数があるとみなされる
  * だからアンダーバーが例えば2つあれば2引数の関数なのだ、という認識をコンパイラはするわけ

== 部分適用 ==
 * アンダーバーによる置き換えは関数の引数リストに対しても適用出来る。
{{{#!highlight scala
def sum(a:Int, b:Int, c:Int) = a + b + c
val sum2 = sum(_:Int, 3, _:Int)
}}}
 * 上の操作によってsum関数の第2引数に3を与えた引数を2つとる関数を新しく作ることが出来た
  * このように関数に引数の一部分だけを適用して新しい関数を得ることを部分適用という
 * 上の操作をした上で下のような操作をすることができる
{{{#!highlight scala
println(sum2(2, 4)) //9が出力される
}}}
 * 部分適用とは言うものの1つも引数を適用しないこともできる
{{{#!highlight scala
def sum(a:Int, b:Int, c:Int) = a + b + c
val sum2 = sum _
}}}
 * 上の操作の結果sum2にはsumと同じ挙動をする3引数の関数が格納されている状態になる

=== 部分適用の内部的動作 ===
 * 次のコードを考える
{{{#!highlight scala
def sum(a:Int, b:Int) = a + b
val sum2 = sum _
}}}
 * sum2にはsumに引数を0個部分適用した結果の2引数関数のオブジェクトが格納されている
 * sum2に格納されているものは実は厳密にはsumで定義されている関数そのものではない
{{{#!highlight scala
sum2(2, 3)
}}}
 * 上の式を評価するとsum2オブジェクトが持っているapplyというメソッドが呼び出され、sum2に対応する関数、すなわちsum関数が取り出され適用されるという形になっている

=== アンダースコアの省略 ===
 * 「その関数式を記述する箇所が関数呼び出し必須である」ようなときアンダースコアを省略することも可能である
{{{#!highlight scala
val yuruyuri = List("Kyoko", "Akari", "Yui", "Chinatsu")
yuruyuri.foreach(println)
// foreachメソッドの引数には呼び出す関数を必ず記述しなければならないため、println(_)のアンダースコアは省略できる
}}}

== クロージャ ==
=== 束縛変数と自由変数 ===
{{{#!highlight scala
(x:Int) => x + more
}}}
 * 上の関数リテラルでxを束縛変数、moreを自由変数と呼ぶ
 * xは関数の引数でInt型であるという事がわかっていて、関数の中で文脈的意味を与えられている
 * moreは突然出てきた変数で、文脈的意味が与えられていない

 * 自由変数も関数リテラルの外でちゃんと意味を与えてやれば(束縛するという)機能する
{{{#!highlight scala
var more = 1
(x:Int) => x + more
}}}

=== 開いた項と閉じた項 ===
 * 自由変数がある関数リテラルを開いた項という。
 * 自由変数がない関数リテラルを閉じた項という。

=== クロージャの定義 ===
 * 開いた項の関数リテラルが束縛された自由変数を掴んで閉じた項になった結果生まれた関数
{{{#!highlight scala
var more = 1
val f = (x:Int) => x + more //これがクロージャ
}}}
 * クロージャはmoreの値を持っているわけではなく、more自体への参照を持っているのでmoreをいじればクロージャの中でのmoreの値も変わる。
{{{#!highlight scala
var more = 1
var f = (x:Int) => x + more

println(f(3)) //4が出力される

more = 10

println(f(3)) //13が出力される
}}}
 * 逆にクロージャから自由変数を変更することもできる
{{{#!highlight scala
val list = List(1,2,3)
var sum = 0
list.foreach(sum += _)
println(sum) //6が出力される
}}}

=== ローカル関数としてクロージャを定義する ===
 * ローカル関数としてクロージャを定義し、そのクロージャの自由変数をクロージャの外側の関数の引数として与えてみる
 * 自由変数moreはmyadd関数の中でのみ通用する変数になっていて、クロージャが生成された時にmyaddに与えられた値がmoreの値になっている
{{{#!highlight scala
def myadd(more:Int) = (x:Int) => x + more

val add10 = myadd(10)
val add100 = myadd(100)

println(add10(10)) //20が出力される
println(add100(10)) //110が出力される
}}}

== 連続パラメータ ==
 * Scalaでは関数の「最後の」引数として可変長引数が渡せる
 * 型指定の後ろにアスタリスクをつける
{{{#!highlight scala
def echo(args:String*) = args.foreach(println)
}}}
 * 連続パラメータは内部的にはArrayとして扱われているが、Arrayを引数として渡そうとすると怒られる
  * Arrayごと渡したいときは後ろに:_*とかく

== 末尾再帰 ==
 * Scalaは関数型言語なのでループを書く際にはwhileなどを使うのではなくなるべく再帰するのがよい
  * ただし末尾再帰になるように書けば再帰で書いても内部的にはただのループに置き換えられるので関数呼び出しのオーバヘッドが発生しないのでおすすめ
  * もちろんforeachメソッドなどが使えるのであればそちらを使うほうが良い

== 高階関数 ==
 * 関数を引数にとったり関数を返したりする関数
  * foreachメソッドは紛れもない高階関数！
=== 高階関数の例 ===
 * 膨大な量の文字列のリストlistがあると仮定する
 * これに対して次のようなものを探したい
  * 先頭が指定文字列と合致する文字列
  * どこかしらが指定文字列と合致する文字列
  * 指定した正規表現とマッチする文字列
 * 普通に書くとこのようになる
{{{#!highlight scala
def listEnds(query:String) = {
  for(str <- list; if str.endsWith(query)) yield str
}
def listContains(query:String) = {
  for(str <- list; if str.contains(query)) yield str
}
def fileRegex(query:String) = {
  for(str <- list; if str.matches(query)) yield str
}
}}}
 * ぶっちゃけ一部を除いてほとんど同じ内容の関数なので、何とかして共通な部分をくくりだしたい
 * 次のような関数を作る
  * matcherはStringを2つ受け取ってBooleanを返す関数式
{{{#!highlight scala
def listMatching(query:String, matcher:(String, String) => Boolean) = {
  for(str <- list; if matcher(str, query)) yield str
}
}}}
 * 上のlistMatchingを使えばlistEnds関数は次のように書ける
{{{#!highlight scala
def listEnding(query:String) = {
    listMatching(query, (str:String, query:String) => str.endsWith(query)
}
}}}

 * プレースホルダーを使ってfilesMatching関数の2引数は省略することが出来て
{{{#!highlight scala
def listEnding(query:String) = listMatching(query, _.endsWith(_))
}}}

 * クロージャを使えば更に短縮することができる
{{{#!highlight scala
def listMatching(matcher:String => Boolean) = {
  for(str <- list; if matcher(str)) yield str
}
def listEnding(query:String) = listMatching(_.endsWith(query))
}}}
 * listMatching関数で使われるqueryをlistMatching関数で束縛するのではなくて外側のlistEnding関数で束縛している。

=== 高階関数もう一例 ===
 * existsメソッドというのがある。existsメソッドはコレクションに適用されるメソッドで、コレクションの要素の中に一つでも与えられた関数式を満足するものがあればTrueを返し、そうでなければFalseを返すというものである。
 * 数値のリストが与えられた時負の数が含まれているかどうかを判定する
{{{#!highlight scala
list.exists(_ < 0)
}}}
 * existsの引数が関数式になっているのでこれも高階関数
 * 嘘だと思う人はこのように書き換えてみよう
{{{#!highlight scala
list.exists(x => x < 0)
}}}

== カリー化 ==
 * 一つの引数リストではなく複数の引数リストに対応できるような関数をカリー化された関数という
{{{#!highlight scala
def plainSum(x:Int, y:Int) = x + y //カリー化されてない
plainSum(2, 3)

def curriedSum(x:Int)(y:Int) = x + y //カリー化されてる
curriedSum(2)(3)
}}}

 * カリー化されている関数はどうなっているのか
  * curriedSum関数は引数xをとってyという1引数の関数にまず化けている
  * そのあと引数yをとってInt型の数値を返している
  * 2段階になってるわけね
　* だから以下の関数とcurriedSumは同じ意味
   * curriedSum2はxを引数にとって「yを引数にとる関数リテラル」を返している
{{{#!highlight scala
def curriedSum2(x:Int) = (y:Int) => x + y
}}}
=== カリー化された関数にプレースホルダーを使ってみる ===
 * カリー化された関数はプレースホルダーを使って引数を固定できる
{{{#!highlight scala
val onePlus = curriedSum(1)_ //一つ目の引数に1を与えて固定してる
onePlus(2) // curriedSum(1)(2)と同じ意味になる
}}}

=== 3引数以上で試してみる ===
 * プレースホルダーは引数全体を一つのアンダースコアで置き換えるので、複数の引数を置き換えるときも1つだけ書けば良い
{{{#!highlight scala
def hoge(x:Int)(y:Int)(z:Int) = x + y + z
val fuga = hoge(1)_
fuga(2, 3) // hoge(1, 2, 3)と同じ意味
}}}

=== カリー化するメリット ===
 * カリー化された関数は部分適用がしやすくなる
 * 例えば足し算をする関数をカリー化しておけば、簡単に適当な数値を部分適用して、その数値の分インクリメントする関数を生成できる

== 制御構造の生成 ==
 * ファイルを開いて書き込んで閉じる操作を行う関数を定義してみる
{{{#!highlight scala
def withPrintWriter(file:File, op:PrintWriter => Unit){
  val writer = new PrintWriter(file)
  try{
    op(writer)
  } finally {
    writer.close()
  }
}

withPrintWriter(new File("date.txt"), writer => writer.println(new java.util.Date))
}}}
 * opはファイル書き込みのためのPrintWriterオブジェクトを引数にとってファイルに実際に書き込み操作を行う操作を定義している関数
 * 操作を定義している関数を外から引数として与えられるようにしたので、ファイルを開いて何か操作をしてファイルを閉じるという操作だけを切り出した関数を作ることができる
 * このような書き方をopに対してファイルを開いて貸してあげているようにみえるため、「ローンパターン」という

 * 引数が1つだけのメソッドは丸括弧の代わりに中括弧を使ってもいい
  * 上のwithPrintWriterをカリー化して中括弧を使えるようにしてみよう
{{{#!highlight scala
def withPrintWriter(file:File)(op:PrintWriter => Unit){
  val writer = new PrintWriter(file)
  try{
    op(writer)
  } finally {
    writer.close()
  }
}

withPrintWriter(new File("date2.txt")){
  writer => writer.println(new java.util.Date)
}
}}}
 * この関数に与えている処理を表す関数が中括弧で囲まれたことで、この部分が処理に対応していることが一目瞭然になった
== 名前渡しパラメータ ==
 * 次のようなプログラムを考える
{{{#!highlight scala
object MyLog {
  val isDebug = true

  def main(args: Array[String]) {
    log(heavyFunc)
  }

  def log(s: String) = { //heavyFuncのデバッグログを取るための関数
    if(isDebug) {
      println("call log")
      println(s)
    }
  }

  def heavyFunc() = {
    println("call heavyFunc") //実際には重い処理が用意されていると考える
    "hoge"
  }
}
}}}
 * このプログラムを実行すると次のような結果になる
{{{#!highlight scala
call heavyFunc
call log
hoge
}}}
 * main関数でlog(heavyFunc)を実行するときにheavyFuncが評価されてしまうためこうなってしまう
  * isDebugをfalseにしてもheavyFuncはやっぱり評価されるので、"call heavyFunc"が出力されて、"hoge"が返される
   * "hoge"はいらないのに！！！
 * heavyFuncの返り値が必要になるまでheavyFuncの評価をしないでほしい
  * 名前渡しする
{{{#!highlight scala
object MyLog {
  val isDebug = true

  def main(args: Array[String]) {
    log(heavyFunc)
  }

  def log(s: => String) = { //ここが書き換わっている
    if(isDebug) {
      println("call log")
      println(s)
    }
  }

  def heavyFunc() = {
    println("call heavyFunc")
    "hoge"
  }
}
}}}
 * 引数に=>をつけて関数を定義するとそこは名前渡しとなって、実際に戻り値が必要になるまで評価されなくなる

=== こんなことしなくても関数を渡すようにすればいいんじゃね ===
{{{#!highlight scala
def log(s: () => String) = { //ここが書き換わっている
  if(isDebug) {
    println("call log")
    println(s)
  }
}
}}}
 * この書き方だと関数じゃなくて文字列を直接渡したいときに苦労する
{{{#!highlight scala
log("hoge") //エラー
log(() => "hoge")) //関数リテラルとして書かないといけない
}}}

== Scala的オブジェクト指向 ==
 * コップ本10章に則って、Scalaにおけるオブジェクト指向の実現手法について見てみる
 * 簡単な2D描画をするライブラリを作る

=== ライブラリの仕様 ===
 * 2Dオブジェクトはelemというメソッドで生成する
 * 生成したオブジェクトはaboveやbesideというメソッドを使って2つを結合することができる
 * 2Dオブジェクトは文字列表現の2次元矩形として定義する

=== 抽象クラス ===
 * 2Dオブジェクトに対応するElementというクラスを用意する
{{{#!highlight scala
abstract class Element {
  def contents:Array[String]
}
}}}
 * contentsは矩形を表現するための文字列の配列
 * Elementは抽象クラスになっている

=== 引数なしメソッドの定義 ===
 * 要素の高さを調べるheightメソッドと幅を調べるwidthメソッドを用意する
{{{#!highlight scala
abstract class Element {
  def contents:Array[String]
  def height:Int = contents.length
  def width:Int = if(height == 0) 0 else contents(0).length
}
}}}
 * 別にdefで定義する必要はなくて、valで定義してしまってもいい
  * 関数がフィールドになりますね
  * このようにScalaではフィールドとメソッドのアクセス方法に区別がない
{{{#!highlight scala
abstract class Element {
  def contents:Array[String]
  val height:Int = contents.length
  val width:Int = if(height == 0) 0 else contents(0).length
}
}}}
 * フィールドにすると初回にその結果を保持するので高速になるがメモリを食う
 * メソッドだと毎回計算数するが、メモリは食わない

=== クラスの継承 ===
 * Elementを継承してArrayElementをつくる
{{{#!highlight scala
class ArrayElement(conts:Array[String]) extends Element {
  def contents:Array[String] = conts
}
}}}
 * Elementは抽象クラスなのでcontentsメソッドを実装しないといけない

=== メソッドとフィールドのオーバーライド ===
 * Scalaではメソッドとフィールドのアクセス方法が同じなので、メソッドとフィールドを相互にオーバーライドできる

=== コンストラクタ ===
 * Scalaではコンストラクタのための専用の構文はない
  * クラス定義の直下にベタ書きした式がそのままコンストラクタになる
{{{#!highlight scala
class Hoge {
  println("hoge") //この部分はHogeを生成した時に実行される
}
}}}
 * 引数付きコンストラクタを定義したいときは次のように書く
{{{#!highlight scala
class Hoge(msg : String) {
  println(msg)
}
}}}

=== 補助コンストラクタ ===
 * 複数の引数リストのためのコンストラクタを定義したいときは補助コンストラクタを使う
{{{#!highlight scala
class Hoge(msg : String) {
  def this() = this("hoge") 引数を与えなかった時のコンストラクタを定義
  println(msg)
}
}}}
 * 補助コンストラクタは複数定義できて、基本コンストラクタか別の補助コンストラクタを必ず呼び出さないといけない

=== パラメータでフィールドを初期化してしまう ===
 * コンストラクタのパラメータがフィールド初期化のためのパラメータなら次のように略して書くこともできる
{{{#!highlight scala
class ArrayElement(val contents:Array[String]) extends Element //valをつけることでフィールドと同じ名前のパラメータを定義できて、直接フィールド初期化ができる
}}}
 * valじゃなくてvarにすれば再代入できるフィールドにできる
 * privateとかをつけることもできる
{{{#!highlight scala
class ArrayElement(private val contents:Array[String]) extends Element
}}}

=== スーパークラスのコンストラクタ呼び出し ===
 * 高さが1の(即ち線になっている)ようなオブジェクトのためのクラスを作ると便利かも
  * LineElementというのを作ります
{{{#!highlight scala
class LineElement(s:String) extends ArrayElement(Array(s)){ //extends ArrayElement(Array(s))と書くことで親クラスのコンストラクタにArray(s)を与えることができる
  override def width = s.length //親クラスをオーバーライドするのでoverrideをつけます
  override def height = 1
}
}}}

=== override修飾子 ===
 * 親クラスで実装済みのメソッドをオーバーライドする時は必ずメソッドの前にoverrideを書かないといけない
 * 親クラスのメソッドが抽象メソッドなら別に要らない
  * さっきも付けなかったよね

=== ポリモーフィズム ===
 * 指定された幅と高さの範囲を、指定された文字で埋め尽くすElement形式であるUniformElementを定義してみる
{{{#!highlight scala
class UniformElement(
  // 範囲を埋め尽くす文字を指定
  ch:Char
  override val width:Int,
  override val height:Int
) extends Element {
  private val line = ch.toString * width
  def contents = Array.make(height, line)
}
}}}
 * 今まで定義したクラスはElementを拡張して作ってきたのでElementの一族として扱える
{{{#!highlight scala
val e1:Element = new ArrayElement(Array("hoge", "huga"))
val e2:Element = new LineElement("hello")
val e3:Element = new UniformElement('x', 3, 4) 
}}}
 * Scalaでは呼び出されるメソッドは変数の型ではなく、オブジェクトがどのクラスから生成されたかに依存する
{{{#!highlight scala
abstract class Element {
  def demo() {println("Element's implementation invoked")}
}

class ArrayElement extends Element {
  override def demo() {println("Array Element's implementation invoked")}
}

class LineElement extends ArrayElement {
  override def demo() {println("Line Element's implementation invoked")}
}

class UniformElement extends Element
}}}
{{{#!highlight scala
val e = new ArrayElement
e.demo() //Array Element's implementation invokedが出力される

val e = new LineElement
e.demo() //Line Element's implementation invokedが出力される

val e = new UniformElement
e.demo() //Element's implementation invokedが出力される
}}}

=== final ===
 * サブクラスにオーバーライドさせたくないものにはfinalをつける
 * クラスそのものをそもそも拡張させたくないときはクラス自体にfinalをつければよい

=== 合成と継承 ===
 * 既存のクラスを利用する方法には合成と継承がある
 * 合成はクラスの持つフィールドのデータ型として別のクラスを指定することで、あるクラスから別のクラスを利用しようとする方法
  * オーバーライドを伴わないので、スーパークラスを書き換えるとサブクラスが使えなくなる、という問題を回避できる
  * オーバーライドを多用するより抽象メソッドの実装という形で実装を心がけるようにしたい
 * 上の例だとLineElementはArrayElementに対して合成の関係ではない
  * ArrayElementにcontentsフィールドの定義を任せてそれを継承して使用しているため
  * 合成の関係にするためにはLineElementをElementの直下に来るようにする
   * contentsはArrayElementで定義されたものを継承したのではなく、自前でArrayクラスをデータ型として指定したものとなっている
{{{#!highlight scala
class lineElement(s:String) extends Element {
  val contents = Array(s)
  override def width = s.length
  override def height = 1
}
}}}
 * この辺の感覚はトレイトを学ぶとつかめるようになる気がする

=== 引数をとるメソッドを定義 ===
 * オブジェクトを連結するメソッドabove, besideを定義します
{{{#!highlight scala
def above(that: Element): Element =  {
  new ArrayElement(this.contents ++ that.contents) // ++ は配列を結合するための演算子
}

def beside(that: Element):Element = {
  new ArrayElement(
    for ((line1, line2) <- this.contents zip that.contents) yield line1 + line2
  )
}
}}}
 * zip演算子は2つの配列から1つずつ要素を取り出してそれを組み合わせた要素を生成し、新しい配列を作るという演算子
 * 出力用のtoStringメソッドも定義しょう
  * toStringはScalaのオブジェクト全てに定義されているので、overrideしないといけない
{{{#!highlight scala
override def toString = contents mkString "\n" //mkStringは引数にとった文字列を糊にしてcontentsの要素を結合するメソッド
}}}

=== ファクトリーメソッド ===
 * コンパニオンオブジェクトを使って実装するのが一番いい
{{{#!highlight scala
object Element {
  def elem(contents:Array[String]):Element = {
    new ArrayElement(contents)
  }

  def elem(char:Char, width:Int, height:Int):Element = {
    new UniformElement(char, width, height)
  }

  def elem(line:String):Element = {
    new LineElement(line)
  }
}
}}}
 * 引数リストの違いに応じて呼び出すコンストラクタを変えることによって、コンストラクタの違いを意識すること無くオブジェクトを生成できる
 * ArrayElement, UniformElement, LineElementはコンパニオンオブジェクトからコンストラクタを呼び出せればいいのでコンパニオンオブジェクトの中で定義してしまうことにする
{{{#!highlight scala
object Element {
  private class ArrayElement(val contents:Array[String]) extends Element

  private class LineElement(s:String) extends Element{
    val contents = Array(s)
    override def width = s.length
    override def height = 1
  }

  private class UniformElement(
    ch:Char,
    override val width:Int,
    override val height:Int
   ) extends Element {
    private val line = ch.toString * width
    def contents = Array.make(height, line)
  }

  def elem(contents:Array[String]):Element = {
    new ArrayElement(contents)
  }

  def elem(char:Char, width:Int, height:Int):Element = {
    new UniformElement(char, width, height)
  }

  def elem(line:String):Element = {
    new LineElement(line)
  }
}
}}}
 * 最後にElementクラスの定義でコンストラクタを呼び出しているところをファクトリーメソッドに置き換えれば完成
  * 省略するのでじぶんでやってみよう

== Scalaのクラス構造 ==
=== Anyクラス ===
 * Scalaのすべてのクラスの親クラス、頂点
  * AnyクラスにはtoStringやequalsメソッドなどが実装されている
 * Anyクラスの直下にはAnyValクラスとAnyRefクラスがある

=== AnyValクラス ===
 * Scalaにおける値をあらわすクラスの親クラス
  * ByteとかIntとかいうクラスの親

=== AnyRefクラス ===
 * Scalaにおける参照クラスの親クラス
  * Scalaでクラスを定義するとこいつの子になる

=== Javaのプリミティブ型との関連 ===
 * Scalaでの数値演算は内部的にはJavaのプリミティブ型に変換して行われている模様
 * 数値をオブジェクトとして扱う必要性が出てきたときは、自動的にオブジェクトとして扱ってくれる
 * Scalaでは==はオブジェクトの値の等価性を判定するためのメソッド
  * 内部的にJavaのequalsメソッドを呼び出している
 * Javaの==と同じように同じオブジェクトであるかどうかを判定したいときはeqメソッドを使う

=== Nullクラス ===
 * すべての参照クラスのサブクラスになる
 * 参照になにもないことを表す
 * 参照クラスのサブクラスだから値型とは互換性がない
  * 例えばInt型の変数にNullを突っ込もうとすると怒られる

=== Nothingクラス ===
 * すべてのクラスのサブクラスになっている
  * どんな型にも化けられる！
 * エラーが発生した時にこいつを返すようにするとエラー判定に便利
{{{#!highlight scala 
def error(message:String):Nothing = throw new RuntimeException(message)
}}}

== トレイト ==
=== トレイトを定義する ===
 * 見た感じクラスと同じ感じ
{{{#!highlight scala
trait Philosophical {
  def philosophize(){
    println("I consume memory, therefore I am!")
  }
}
}}}

=== トレイトを使う ===
 * 既存のクラスにミックスインして使う
  * Java風に言えば実装する
 * すでにextendsを使っているときはwith, 使ってないときはextends
{{{#!highlight scala
class Kyoko extends Philosophical

val kyoko = new Kyoko
kyoko.philosophize()
I consume memory, therefore I am!
}}}

=== スーパークラスを持っているクラスにミックスイン ===
{{{#!highlight scala
class Human

class Kyoko extends Human with Philosophical

val kyoko = new Kyoko
kyoko.philosophize()
I consume memory, therefore I am!
}}}

=== 複数トレイトのミックスイン ===
 * クラスと違いトレイトは複数ミックスインできる

{{{#!highlight scala
class Human

trait hasLeg

class Kyoko extends Human with Philosophical with hasLeg

val kyoko = new Kyoko
kyoko.philosophize()
I consume memory, therefore I am!
}}}

=== トレイトのメソッドのオーバーライド ===
 * トレイトで定義されたメソッドはオーバーライドできる

=== トレイトとは結局何か ===
 * コンストラクタ引数をとれないクラスぐらいに考えてしまっていい
 * トレイトは道具箱のようなもの
  * クラスという作業場を用意しておいて、必要なメソッド(道具)をトレイトから引っ張り出してくるイメージ
  * トレイトを使うことで貧弱なインタフェースに処理を付け足してリッチなインターフェースを作ることができる

=== トレイトを実際に使ってみる ===
 * Scalaに標準で用意されているOrderedトレイトというのを使ってみる
 * 有理数を提供するクラスRationalというものがあるとする
  * こいつに>, >=, <, <=というメソッドを用意したい
   * ２つのRationalを引数にとってBooleanを返すメソッド
   * 普通に頑張ってそれぞれのメソッドを実装してもいいけど、Orderedトレイトを使うと簡単に実装できる
{{{#!highlight scala
class Rational(n:Int, d:Int) extends Ordered[Rational]{
  def compare(that:Rational) = //compareの値が正、負、0のどれかになるかという結果をもとに比較演算子の結果を求めるような仕組みになっている
    (this.numer * that.denom) - (that.numer * this.denom) //numerは分子, denomは分母に対応するフィールド
}
}}}

=== 積み重ね可能な変更 ===
 * 整数のキューを考える
{{{#!highlight scala
abstract class IntQueue {
  def get():Int
  def put(x:Int)
}

import scala.collection.mutable.ArrayBuffer
class BasicIntQueue extends IntQueue {
  private val buf = new ArrayBuffer[Int] //mutableになっている

  def get() = buf.remove(0)
  def put(x:Int){ buf += x } 
}
}}}
 * 整数を追加するときに整数を2倍にして追加できるようにするトレイトをつくってみる
{{{#!highlight scala
trait Doubling extends IntQueue {
  abstract override def put(x:Int){super.put(2 * x)}
}
}}}
 * トレイト宣言でextendsキーワードを用いるとIntQueueクラスを拡張したクラスにしかミックスインできないようになる
 * extendsで明示的に親クラスを指定することでsuperキーワードを使って親クラスのメソッドを参照できる
  * 実際にはIntQueueクラスではputメソッドは抽象メソッドになっているので、具体的な実装を行なっているBasicIntQueueクラスのputメソッドが呼び出される
   * という認識でいいのかな
 * abstract overrideと書くことによってコンパイラに対して、既存のputメソッドに対して更に変更を加えているんだよということを示している

{{{#!highlight scala
class MyQueue extends BasicIntQueue with Doubling

val queue = new MyQueue
queue.put(10)
queue.get() //20が出てくる
}}}

 * いちいち使い捨てのクラスを作るのもアレだよね
  * newするときに一緒にミックスインの指定ができる
{{{#!highlight scala
val queue = new BasicIntQueue with Doubling
queue.put(10)
queue.get() //20が出てくる
}}}

 * 複数のトレイトで積み重ねをやってみる
{{{#!highlight scala
// 待ち行列の値に1加えるトレイト
trait Incrementing extends IntQueue {
  abstract override def put(x:int){super.put(x +1)}
}

// 待ち行列に負の数を加えないようにするトレイト
trait Filtering extends IntQueue {
  abstract override def put(x:int){ if(x >= 0) super.put(x)}
}
}}}

{{{#!highlight scala
val queue = new BasicIntQueue with Incrementing with Filtering

queue.put(-2);queue.put(-1);queue.put(0);

queue.get() //1が出てくる

queue.get() //エラー
}}}
 * 上の挙動から複数のミックスインは右から行われることがわかる
 * つまりトレイトを適用する順番によって挙動が変わる！！
  * これは強力だけど、同時に危険性もある

=== 多重継承ではなくトレイトによるミックスインを採用した理由 ===
 * 菱型継承をした時の問題を解決するため

=== ミックスインの線形化 ===
 * 複数のトレイトをミックスインするときどの順番にミックスインされるのか
{{{#!highlight scala
class Animal

trait Furry extends Animal
trait HasLegs extends Animal
trait FourLegged extends HasLegs

class Cat extends Animal with Furry with FourLegged
}}}
{{{#!highlight scala
Animal→AnyRef→Any //Animalはこのような階層構造になっている
Furry → Animal → AnyRef → Any　//Furryトレイトは次のような構造
Cat→FourLegged→HasLegs→Furry→Animal→AnyRef→Any //Catクラスはこのような構造
}}}
 * 自分から始めて右から順番に適用されると思っておけばよいかと

== case class ==
 * クラス宣言の前にcaseというキーワードをつけると色々と便利なクラスであるcase classを作ることができる。
=== ケースクラスの利点 ===
 * インスタンス化するときにnewを付けなくていい
  * ケースクラスには必ずコンパニオンオブジェクトがセットで勝手についてくるから
{{{#!highlight scala
case class Foo(name: String)
val foo = Foo("foo")
}}}
 * getterが勝手に生成される
  * 以下の例の場合nameという名前のname変数のgetterが勝手に生成されている
{{{#!highlight scala
case class Foo(name: String)
val foo = new Foo("bar")
foo.name // "bar"
}}}

 * equals, hashCode, toStringが自動生成される

 * ケースクラスはパターンマッチの条件として使うことができる
  * 後述

== パターンマッチ ==
=== 基本的なパターンマッチ ===
 * 基本的なパターンマッチは次のように書く。前にやったmatch式を使ったものがそれ。
{{{#!highlight scala
def hoge(i:Int):String = i match {
  case 1 => "1です"
  case _ => "1以外です"
}
}}}

=== 型によるパターンマッチ ===
 * 値ではなくてその変数の型によってマッチングすることもできる
{{{#!highlight scala
def printKind(elem: Any) = elem match {
    case str: String => println("String") //String型の時
    case i: Int => println("Integer") //Int型の時
    case _ => println("Other") //その他の時
}
}}}

=== 変数を使ったパターンマッチ ===
 * マッチした結果を変数に突っ込んで使うことができる
{{{#!highlight scala
def printKind(elem: Any) = elem match {
    case str: String => println("String " + str) //String型の時"String (elemの中身)"
    case i: Int => println("Integer " + i) //Int型の時"Integer (elemの中身)"
    case _ => println("Other") //その他の時
}
}}}

=== case文とmatch式の違い ===
 * Javaのcase文とScalaのmatch式の違い
  * match式は値を返す
  * 該当するものがあった時、それ以降のものは評価されない
  * 条件は全てのパターンを網羅しないといけない

=== ワイルドカードによるマッチ ===
 * 以下次のサンプルコードを使う
{{{#!highlight scala
abstract class Expr

// 変数定義クラス 
case class Var(name:String) extends Expr
// 数値定義クラス
case class Number(num:Double) extends Expr
// 単項演算クラス
case class UnOp(opearator:String, arg:Expr) extends Expr
// 二項演算クラス
case class BinOp(opearator:String, left:Expr, right:Expr) extends Expr
}}}

 * あらゆるオブジェクトにマッチするパターンはアンダースコアで表す。
  * 今までにも使ってきたよね
{{{#!highlight scala
def test(expr:Expr) = expr match {
  case BinOp(op, left , right) => println(expr + " は2項演算")
  case _ => //何も書かないと何も起きない
}
}}}
{{{#!highlight scala
test(BinOp("+", Number(1), Number(3))) //「BinOp(+,Number(1.0),Number(3.0)) は2項演算」と出力される

test(UnOp("+", Number(3)))  // 何も出ない
}}}

 * ワイルドカードはパターン全体ではなくパターンの条件の要素として使うこともできる

{{{#!highlight scala
def test(expr:Expr) = expr match {
  case BinOp(_, _ , _) => println(expr + "は2項演算")
  case _ => println("2項演算以外")
}
}}}
{{{#!highlight scala
test(BinOp("+", Number(1), Number(3))) // 「BinOp("+", Number(1), Number(3))は2項演算」と出力される
}}}

=== 定数パターンマッチ ===
 * リテラルを使って完全一致でパターンマッチする
{{{#!highlight scala
def describe(x:Any) = x match {
  case 5 => "五"
  case true => "真"
  case "hello" => "はろう"
  // 空リストにマッチするシングルトンオブジェクト
  case Nil => "空のリスト"
  case _ => "Other"
}
}}}

=== 定数パターンマッチの注意点 ===
 * 定数パターンマッチにはシンボル名を使うことができる
 * Scalaの字句解析では小文字で始まる単語は変数、大文字で始まる単語は定数としてみなされる
  * この辺りで混乱が発生することがある
{{{#!highlight scala
import Math.{E, Pi}

E match {
  case Pi => "Pi"
  case _ => "Other"
} // 式の結果は"Other"になる。EとPiはそれぞれ定数とみなされる。定数パターンマッチでは完全一致しないと行けないから別物としてみなされる。
}}}
 * Piを小文字にすると問題が起きる
{{{#!highlight scala
import Math.{E, Pi}
val pi = Math.Pi

E match {
  case pi => "Pi"
  case _ => "Other"
} // コンパイルエラー。最初のcase piが変数のパターンマッチになりここにすべてのオブジェクトがマッチしてしまう。なのでcase _が余分なものと判断されエラー
}}}

 * これを防ぐためにはpiをバッククオートで囲めば、piが定数扱いになる。

=== シーケンスパターン ===
 * ListやArrayとマッチングする。
  * 先頭が0で要素が3つあるようなListとだけマッチングする例
{{{#!highlight scala
def test(list:Any) = list match {
  case List(0, _, _) => println("hoge")
  case _ =>
}
}}}

 * 「_*」を使うことによって任意の個数の要素とマッチングできる
  * 先頭が0であるようなListとマッチングする例
{{{#!highlight scala
def test(list:Any) = list match {
  case List(0, _*) => println("hoge")
  case _ =>
}
}}}

=== タプルパターン ===
 * Listで出来るんだからタプルでもできる。
{{{#!highlight scala
def testTuple(tuple:Any) = tuple match {
  case (a, b, c) => println("triple tuple")
  case _ => 
}
}}}

=== パターンの変数への束縛 ===
 * パターンを<変数名> @ [パターン]という形で変数に束縛できる
{{{#!highlight scala
abstract class Expr
/ 数値定義クラス
case class Number(num:Double) extends Expr
// 単項演算クラス
case class UnOp(opearator:String, arg:Expr) extends Expr

// 絶対値演算2回を1回に置き換える処理
// 絶対値演算は1回やっても2回やっても同じ結果になる
def test(expr:Expr) = expr match{
  case UnOp("abs", e @ UnOp("abs", _)) => e
  case _ =>
}
}}}

=== ケースクラスによるマッチング ===
 * ケースクラスは定義するだけでマッチングに使用することができる
{{{#!highlight scala
abstract class Name
case class FirstName(name: String) extends Name
case class LastName(name: String) extends Name
def printName(name:Name): Unit = {
  name match {
    case FirstName(name) => println(name)
    case LastName(name) => println(name.toUpperCase)
    case _ =>
  }
}
printName(FirstName("Martin"))   // "Martin"
printName(LastName("Odersky")) // "ODERSKY"
}}}

=== パターンガード ===
 * パターンには変数を一度しか登場させることが出来ない
{{{#!highlight scala
def guardPattern(e:Expr) = e match {
  case BinOp("+", x ,x) => BinOp("*", x, Number(2)) //パターンにxが2回出てきているのでコンパイルエラーになる
  case _ => e
}
}}}
 * パターンにはif式を使って条件を付け加えることができるのでそれを利用する
{{{#!highlight scala
def guardPattern(e:Expr) = e match {
  case BinOp("+", x ,y) if x == y => BinOp("*", x, Number(2)) 
  case _ => e
}
}}}

=== sealed class ===
 * クラス宣言にsealedというキーワードを付けることで同じファイルのクラスからしか継承できないようになる
  * サブクラスが必ず同じファイルにあることが保証される
  * クラス型を使ったパターンマッチングの時sealed classを使うことで、ファイルの中のサブクラスを調べて、サブクラスをmatch式がきちんと網羅しているかをコンパイル時に調べてくれる
 * 下の式はPiyoをmatch式が網羅していないので、コンパイル時にWarningが出る
  * Piyoに関するcaseも追加すると、今度はエラーになる
   * FugaにもPiyoにもマッチングしなかった時の条件が書かれていないから
{{{#!highlight scala
sealed class Hoge
class Fuga extends Hoge
class Piyo extends Hoge

def describe(e:Hoge):String = e match {
  case Fuga => "Fuga"
}
}}}

== Option型 ==
 * Option型は値があるかどうか(Nullかどうか)わからないものを扱うときに使う型
  * これをうまく使えばぬるぽを回避できるぞ！！！
 * Option型には2つの値がある
  * 値があることを表すSome(あーだこーだ)
  * 値がないことを表すNone

=== Option型を返す関数を作る ===
 * ファイルが存在すればファイルに対応するオブジェクトを返し、なければNoneを返す関数
{{{#!highlight scala
def findFile( filename:String):Option[File] = {
  val file = new File(filename)
  if( file.exists ) Some(file)  // Fileが存在したらSomeに入れて返す
  else None                     // ないならNoneオブジェクトを返す
}
}}}

=== Option型のメリット ===
 * Option型を返すような関数は確実に意味のある値を返すかどうかわからないということ
  * プログラミングするときに気をつけられる
 * Option型はそのままでは普通の値として扱えないので型によって未然に操作ミスを防ぐことができる

=== Someから値を取り出す ===
 * 値が存在するときSomeに値を入れて返すが、このままでは取り扱えないので取り出す必要がある。
 * Someにはgetというメソッドがあるのでそれを使えば取り出せる
  * でもこれをNoneに対して実行すると例外が投げられる
  * マジ使えねえ、うんこ。
 * パターンマッチを使うのが常道
  * Option型はsealed class
  * Someはcase classになっている
  * Some(f)という形でパターンマッチすることで、自然にfにSomeの中身を取り出すことができる
{{{#!highlight scala
val file = findFile("hoge")
file match {
  case Some(f) => "exists! " + f.getName
  case None => "Nothing!"
}
}}}

== 応用的なパターンマッチ ==
=== 変数定義の際のパターンマッチ ===
 * varやvalを定義するときにパターンマッチを行なって複雑な代入をすることができる
{{{#!highlight scala
val testTuple = (123, "abc")
val (number, str) = testTuple //numberに123, strに"abc"が束縛される
}}}

=== 関数リテラルの中でパターンマッチする ===
 * 関数リテラルの中にパターンマッチを記述することができる
{{{#!highlight scala
val withDefault:Option[Int] => Int = { //Option[Int]を受け取ってIntを返すような関数リテラルを定義した！
  case Some(x) => x
  case None => 0
}
}}}

=== for式でのパターンマッチ ===
{{{#!highlight scala
val greetings = List(("hello", "scala"), ("hi", "python"), ("bye" , "php"))
for ((greeting, language) <- greetings) println(greeting + ' ' + language) //Listの要素のTupleを取り出して1つ目の要素をgreeting, 2爪の要素をlanguageに束縛している
}}}

== Listの実装 ==
=== List型 ===
 * List型はList[T]という型になっている。TにはStringとかIntとか他の型名が入る。
 * List[S]とList[T]があって、SがTのサブ型であればList[S]はList[T]のサブ型になる
 * 空のリストはList[Nothing]型
  * Nothingは全てのクラスのサブクラスなので、空のリストは全てのリストの型に対してサブ型になっている

=== Listの生成 ===
 * リストの要素を直接突っ込む方法を今まで使ってきた
 * ::(cons)を使って構成する方法もある
  * 今まで使ってきた方法は全てこのconsを使った方法の言い換えだった
{{{#!highlight scala
val list = 1 :: 2 :: 3 :: Nil //終わりを明示するため最後はNilにしないといけない
}}}

=== Listの基本操作 ===
 * head...リストの先頭要素を返す
 * tail...リストの先頭を除いた要素から構成されるリストを返す
 * isEmpty...リストが空リストならtrueを返す

=== Listの様々な操作 ===
 * length...リストの長さを返す
 * last...リストの最後の要素を返す(headと比べて重い)
 * init...リストの最後の要素を除いた要素から構成されるリストを返す(tailと比べて重い)
 * reverse...リストを反転したリストを返す
 * take...整数の引数nをとって先頭n個の要素を返す
 * drop...整数の引数nをとって先頭n個以外の要素を返す
 * splitAt...整数の引数nをとってそこの添字でリストを分割して2つのリストをタプルに突っ込んで返す
 * apply...整数の引数nをとってn番目の要素を返す
 * indices...リストの添字のリストを返す
{{{#!highlight scala
List("a","b","c","d","e").indices // List(0, 1, 2, 3, 4)が返ってくる
}}}
 * zip...2つのリストの各要素をまとめたタプルを要素とするリストを返す
{{{#!highlight scala
List(1,2,3,4,5).zip(List("a","b","c","d","e")) // List((1,"a"), (2,"b"), (3,"c"), (4,"d"), (5,"e"))が返ってくる
}}}
 * toArray...リストを配列に変換する
 * toList...配列をリストに変換する
 * copyToArray...指定された添字の位置からリストの要素を置換して配列にする
{{{#!highlight scala
val arr = Array(1,2,3,4,5,6,7,8,9)
List(1,2,3,4,5).copyToArray(arr, 3)　// Array(1, 2, 3, 1, 2, 3, 4, 5, 9)が返ってくる
}}}
 * elements...リストに対するイテレータを返す。以下イテレータのメソッド。
  * hasNext...次の要素があるかどうかを調べる
  * next...次の要素を返す

=== リストに適用する高階メソッド ===
 * map...リストの各要素に引数に与えた関数を適用する
 * foreach...リストの各要素に引数に与えた手続きを適用する
  * 手続きとは戻り値がUnit型であるような関数
  * 戻り値がUnit型なので結果をリストとして回収することは出来ない
 * filter...引数に与えた論理式に合致する要素だけを取り出す
 * partition...引数に与えた論理式に対して(合致した要素を集めたリスト, 合致しなかった要素を集めたリスト)というタプルをつくって返す
 * find...引数に与えた論理式に対して合致する最初の要素を返す。これはOption型を返す関数。
 * takeWhile...引数に与えた論理式に当てはまる要素を頭から順番に取れるだけ取って行って、当てはまらない要素にぶつかったらそこで終わりにする関数
 * dropWhile...takeWhileは条件に当てはまるものを拾っていくが、dropWhileは逆に捨てる
 * span...takeWhileした結果とdropWhileした結果をタプルにして返す
 * exists...引数に与えた条件に当てはまる要素が一つでもあればtrueを返す
 * forall...引数に与えた条件にすべての要素が当てはまればtrueを返す

=== 畳み込み ===
 * 左畳込み
  * (z /: list) (二項演算) という書式で書く
   * まずzとlistの1つ目の要素について二項演算を行う
   * その結果とlistの2つ目の要素について二項演算を行う
   * 繰り返し
 * 右畳込み
  * (list :\ z)(二項演算)
   * zとlistの一番最後の要素について二項演算を行う
   * その結果とlistの後ろから2番めの要素について二項演算を行う
   * 繰り返し

=== Listコンパニオンオブジェクトに実装されているメソッド ===
 * List.apply……リストの生成を行う
{{{#!highlight scala
val list = List.apply(1, 2, 3) //listにList(1, 2, 3)が束縛される
}}}
 * List.range……整数の範囲を生成する
  * List.range(from, until)でfrom以上until未満の整数のリストを生成
  * 3つ目のパラメータを指定するといくつ刻みにするかを決められる
 * List.make……同じ値が並んだリストをつくる
  * List.make(num, element)でnum個のelementが並んだリストが生成される
 * List.unzip……zipでまとめたリストを再びバラす。バラされたリストはタプルに突っ込まれて返ってくる
 * List.flatten……リストの中にリストが入れ子になっているようなものを引数にとって、その要素からなるリストを生成して返す
 * List.concat……複数のリストを引数にとってひとつに結合したリストを返す
 * map2, forall2, exists2……2つのリストと2つの引数をとる関数をもらって、map, forall, exists的なことをする関数