1 scala> 1+1
   2 res0: Int = 2

   1 scala> res0 * 5
   2 res1: Int = 10

   1 scala> println("Hello, world!")
   2 Hello, world!

   1 scala> val msg = "Hello, world!"
   2 msg: String = Hello, world!

   1 scala> val msg2:String = "Hello, world!"
   2 msg2: String = Hello, world!

   1 scala> val msg = "Hello, world!!"
   2 <console>:8: error: reassignment to val
   3        msg = "Hello, World!!"

   1 def 関数名(引数名:引数型, 引数名:引数型, ...):戻り値型 = 関数の式

   1 def hello(name:String):String = {
   2   return "Hello! " + name
   3 }

   1 def hello(name:String):String = {
   2   "Hello! " + name
   3 }

   1 def hello(name:String) = {
   2   "Hello! " + name
   3 }

   1 def hello(name:String) = "Hello! " + name

   1 object hoge
   2   def main(args:Array[String]) = {
   3     //メインの処理
   4   }
   5 }

   1 var i = 0
   2 while(i < args.length) {
   3   println(args(i))
   4   i += 1
   5 }

   1 args.foreach((arg:String) => println(arg))

   1 args.foreach(arg => println(arg))

   1 val hoge = Array[String](3)

   1 hoge(2) = "kyoko"
   2 println(hoge(2))

   1 val hoge = Array("Akari", "Kyoko", "Yui", "Chinatsu")

   1 val hoge = List(2, 3, 5, 7)

   1 val hoge = List(2, 3)
   2 val fuga = List(5, 7)
   3 val piyo = hoge ::: fuga

   1 val hoge = List(3, 5, 7)
   2 val fuga = 2 :: hoge

   1 hoge.::(2)

   1 val hoge = (1, "Kyoko", 2, "Akari")

   1 println(hoge._2)  // Kyoko と表示される
   2 

   1 class Hoge {
   2   var hoge = 1 //フィールド
   3   var fuga = 3 //フィールド
   4 
   5   def myMultiple() = hoge * fuga //メソッド
   6 }

   1 val a = new Hoge()

   1 a.hoge = 2  // OK
   2 

   1 private def hello() = "Hello, World!"

   1 object Hoge {
   2   // あーだこーだ
   3 

   1 `hoge //hogeのシンボルリテラル
   2 

   1 val hoge = "hoge"
   2 val hoge2 = "hoge" //hogeとhoge2は違うオブジェクトになっている
   3 
   4 val fuga = `fuga
   5 val fuga2 = `fuga //fugaとfuga2は同じオブジェクト
   6 

   1 1 + 2
   2 (1).+(2)  // この2つは同じ意味
   3 

   1 "hoge" == "hoge" //かならずTrue
   2 

   1 0 min 5 // min演算子で計算されて結果が0になる
   2 

   1 if (条件式) {
   2   //真の時の式
   3 }else{
   4   //偽の時の式
   5 }

   1 val hoge = "hoge"
   2 println(if (!hoge.isempty) hoge else "default")

   1 var a = x
   2 var b = y
   3 while(a != 0){
   4   val temp = a
   5   a = b % a
   6   b = temp
   7 }

   1 val yuruyuri = List("Kyoko", "Akari", "Yui", "Chinatsu")
   2 for(member <- yuruyuri){
   3   println(member)
   4 }

   1 for(i <- 1 to 10) println(i) //(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)という数列が生成される
   2 for(i <- 1 until 10) println(i) //(1, 2, 3, 4, 5, 6, 7, 8, 9)という数列が生成される
   3 

   1 val yuruyuri = List("Kyoko", "Akari", "Yui", "Chinatsu")
   2 for(member <- yuruyuri if member.endsWith("i")){
   3   println(member)
   4 }

   1 for(i <- 1 to 9; j <- 1 to 9) println(i*j)

   1 val hoge = for (i <- 0 to 5) yield i+1

   1 try{
   2   //例外が発生しそうな処理を書く
   3 }catch{
   4     case e: 例外名  => 例外処理
   5 }

   1 val yuruyuri = "kyoko"
   2 yuruyuri match {
   3   case "kyoko" => println("so cute")
   4   case "akari" => println("who is she?")
   5   case _ => println("so so") // _ はdefaultに相当
   6 }

   1 val yuruyuri = "kyoko"
   2 val result = yuruyuri match {
   3   case "kyoko" => "so cute"
   4   case "akari" => "who is she?"
   5   case _ => "so so"
   6 }
   7 println(result)

   1 def calc(a:Int, b:Int) = {
   2   def add() = a + b
   3   def sub() = a - b
   4   (add, sub)
   5 }

   1 arg => println(arg)

   1 val hoge = (x:Int) => x+1
   2 println(hoge(10))

   1 val yuruyuri = List("Kyoko", "Akari", "Yui", "Chinatsu")
   2 yuruyuri.foreach(println(_))
   3 // yuruyuri.foreach(x => println(x))と同じ
   4 

   1 val myadd = _ + _ //エラーが出る
   2 

   1 val myadd = (_:Int) + (_:Int)
   2 println(myadd(2, 3))

   1 def sum(a:Int, b:Int, c:Int) = a + b + c
   2 val sum2 = sum(_:Int, 3, _:Int)

   1 println(sum2(2, 4)) //9が出力される
   2 

   1 def sum(a:Int, b:Int, c:Int) = a + b + c
   2 val sum2 = sum _

   1 def sum(a:Int, b:Int) = a + b
   2 val sum2 = sum _

   1 sum2(2, 3)

   1 val yuruyuri = List("Kyoko", "Akari", "Yui", "Chinatsu")
   2 yuruyuri.foreach(println)
   3 // foreachメソッドの引数には呼び出す関数を必ず記述しなければならないため、println(_)のアンダースコアは省略できる
   4 

   1 (x:Int) => x + more

   1 var more = 1
   2 (x:Int) => x + more

   1 var more = 1
   2 val f = (x:Int) => x + more //これがクロージャ
   3 

   1 var more = 1
   2 var f = (x:Int) => x + more
   3 
   4 println(f(3)) //4が出力される
   5 
   6 more = 10
   7 
   8 println(f(3)) //13が出力される
   9 

   1 val list = List(1,2,3)
   2 var sum = 0
   3 list.foreach(sum += _)
   4 println(sum) //6が出力される
   5 

   1 def myadd(more:Int) = (x:Int) => x + more
   2 
   3 val add10 = myadd(10)
   4 val add100 = myadd(100)
   5 
   6 println(add10(10)) //20が出力される
   7 println(add100(10)) //110が出力される
   8 

   1 def echo(args:String*) = args.foreach(println)

   1 def listEnds(query:String) = {
   2   for(str <- list; if str.endsWith(query)) yield str
   3 }
   4 def listContains(query:String) = {
   5   for(str <- list; if str.contains(query)) yield str
   6 }
   7 def fileRegex(query:String) = {
   8   for(str <- list; if str.matches(query)) yield str
   9 }

   1 def listMatching(query:String, matcher:(String, String) => Boolean) = {
   2   for(str <- list; if matcher(str, query)) yield str
   3 }

   1 def listEnding(query:String) = {
   2     listMatching(query, (str:String, query:String) => str.endsWith(query)
   3 }

   1 def listEnding(query:String) = listMatching(query, _.endsWith(_))

   1 def listMatching(matcher:String => Boolean) = {
   2   for(str <- list; if matcher(str)) yield str
   3 }
   4 def listEnding(query:String) = listMatching(_.endsWith(query))

   1 list.exists(_ < 0)

   1 list.exists(x => x < 0)

   1 def plainSum(x:Int, y:Int) = x + y //カリー化されてない
   2 plainSum(2, 3)
   3 
   4 def curriedSum(x:Int)(y:Int) = x + y //カリー化されてる
   5 curriedSum(2)(3)

   1 def curriedSum2(x:Int) = (y:Int) => x + y

   1 val onePlus = curriedSum(1)_ //一つ目の引数に1を与えて固定してる
   2 onePlus(2) // curriedSum(1)(2)と同じ意味になる
   3 

   1 def hoge(x:Int)(y:Int)(z:Int) = x + y + z
   2 val fuga = hoge(1)_
   3 fuga(2, 3) // hoge(1, 2, 3)と同じ意味
   4 

   1 def withPrintWriter(file:File, op:PrintWriter => Unit){
   2   val writer = new PrintWriter(file)
   3   try{
   4     op(writer)
   5   } finally {
   6     writer.close()
   7   }
   8 }
   9 
  10 withPrintWriter(new File("date.txt"), writer => writer.println(new java.util.Date))

   1 def withPrintWriter(file:File)(op:PrintWriter => Unit){
   2   val writer = new PrintWriter(file)
   3   try{
   4     op(writer)
   5   } finally {
   6     writer.close()
   7   }
   8 }
   9 
  10 withPrintWriter(new File("date2.txt")){
  11   writer => writer.println(new java.util.Date)
  12 }

   1 object MyLog {
   2   val isDebug = true
   3 
   4   def main(args: Array[String]) {
   5     log(heavyFunc)
   6   }
   7 
   8   def log(s: String) = { //heavyFuncのデバッグログを取るための関数
   9     if(isDebug) {
  10       println("call log")
  11       println(s)
  12     }
  13   }
  14 
  15   def heavyFunc() = {
  16     println("call heavyFunc") //実際には重い処理が用意されていると考える
  17     "hoge"
  18   }
  19 }

   1 call heavyFunc
   2 call log
   3 hoge

   1 object MyLog {
   2   val isDebug = true
   3 
   4   def main(args: Array[String]) {
   5     log(heavyFunc)
   6   }
   7 
   8   def log(s: => String) = { //ここが書き換わっている
   9     if(isDebug) {
  10       println("call log")
  11       println(s)
  12     }
  13   }
  14 
  15   def heavyFunc() = {
  16     println("call heavyFunc")
  17     "hoge"
  18   }
  19 }

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

   1 log("hoge") //エラー
   2 log(() => "hoge")) //関数リテラルとして書かないといけない
   3 

   1 abstract class Element {
   2   def contents:Array[String]
   3 }

   1 abstract class Element {
   2   def contents:Array[String]
   3   def height:Int = contents.length
   4   def width:Int = if(height == 0) 0 else contents(0).length
   5 }

   1 abstract class Element {
   2   def contents:Array[String]
   3   val height:Int = contents.length
   4   val width:Int = if(height == 0) 0 else contents(0).length
   5 }

   1 class ArrayElement(conts:Array[String]) extends Element {
   2   def contents:Array[String] = conts
   3 }

   1 class Hoge {
   2   println("hoge") //この部分はHogeを生成した時に実行される
   3 }

   1 class Hoge(msg : String) {
   2   println(msg)
   3 }

   1 class Hoge(msg : String) {
   2   def this() = this("hoge") 引数を与えなかった時のコンストラクタを定義
   3   println(msg)
   4 }

   1 class ArrayElement(val contents:Array[String]) extends Element //valをつけることでフィールドと同じ名前のパラメータを定義できて、直接フィールド初期化ができる
   2 

   1 class ArrayElement(private val contents:Array[String]) extends Element

   1 class LineElement(s:String) extends ArrayElement(Array(s)){ //extends ArrayElement(Array(s))と書くことで親クラスのコンストラクタにArray(s)を与えることができる
   2   override def width = s.length //親クラスをオーバーライドするのでoverrideをつけます
   3   override def height = 1
   4 }

   1 class UniformElement(
   2   // 範囲を埋め尽くす文字を指定
   3   ch:Char
   4   override val width:Int,
   5   override val height:Int
   6 ) extends Element {
   7   private val line = ch.toString * width
   8   def contents = Array.make(height, line)
   9 }

   1 val e1:Element = new ArrayElement(Array("hoge", "huga"))
   2 val e2:Element = new LineElement("hello")
   3 val e3:Element = new UniformElement('x', 3, 4) 

   1 abstract class Element {
   2   def demo() {println("Element's implementation invoked")}
   3 }
   4 
   5 class ArrayElement extends Element {
   6   override def demo() {println("Array Element's implementation invoked")}
   7 }
   8 
   9 class LineElement extends ArrayElement {
  10   override def demo() {println("Line Element's implementation invoked")}
  11 }
  12 
  13 class UniformElement extends Element

   1 val e = new ArrayElement
   2 e.demo() //Array Element's implementation invokedが出力される
   3 
   4 val e = new LineElement
   5 e.demo() //Line Element's implementation invokedが出力される
   6 
   7 val e = new UniformElement
   8 e.demo() //Element's implementation invokedが出力される
   9 

   1 class lineElement(s:String) extends Element {
   2   val contents = Array(s)
   3   override def width = s.length
   4   override def height = 1
   5 }

   1 def above(that: Element): Element =  {
   2   new ArrayElement(this.contents ++ that.contents) // ++ は配列を結合するための演算子
   3 }
   4 
   5 def beside(that: Element):Element = {
   6   new ArrayElement(
   7     for ((line1, line2) <- this.contents zip that.contents) yield line1 + line2
   8   )
   9 }

   1 override def toString = contents mkString "\n" //mkStringは引数にとった文字列を糊にしてcontentsの要素を結合するメソッド
   2 

   1 object Element {
   2   def elem(contents:Array[String]):Element = {
   3     new ArrayElement(contents)
   4   }
   5 
   6   def elem(char:Char, width:Int, height:Int):Element = {
   7     new UniformElement(char, width, height)
   8   }
   9 
  10   def elem(line:String):Element = {
  11     new LineElement(line)
  12   }
  13 }

   1 object Element {
   2   private class ArrayElement(val contents:Array[String]) extends Element
   3 
   4   private class LineElement(s:String) extends Element{
   5     val contents = Array(s)
   6     override def width = s.length
   7     override def height = 1
   8   }
   9 
  10   private class UniformElement(
  11     ch:Char,
  12     override val width:Int,
  13     override val height:Int
  14    ) extends Element {
  15     private val line = ch.toString * width
  16     def contents = Array.make(height, line)
  17   }
  18 
  19   def elem(contents:Array[String]):Element = {
  20     new ArrayElement(contents)
  21   }
  22 
  23   def elem(char:Char, width:Int, height:Int):Element = {
  24     new UniformElement(char, width, height)
  25   }
  26 
  27   def elem(line:String):Element = {
  28     new LineElement(line)
  29   }
  30 }

   1 def error(message:String):Nothing = throw new RuntimeException(message)

   1 trait Philosophical {
   2   def philosophize(){
   3     println("I consume memory, therefore I am!")
   4   }
   5 }

   1 class Kyoko extends Philosophical
   2 
   3 val kyoko = new Kyoko
   4 kyoko.philosophize()
   5 I consume memory, therefore I am!

   1 class Human
   2 
   3 class Kyoko extends Human with Philosophical
   4 
   5 val kyoko = new Kyoko
   6 kyoko.philosophize()
   7 I consume memory, therefore I am!

   1 class Human
   2 
   3 trait hasLeg
   4 
   5 class Kyoko extends Human with Philosophical with hasLeg
   6 
   7 val kyoko = new Kyoko
   8 kyoko.philosophize()
   9 I consume memory, therefore I am!

   1 class Rational(n:Int, d:Int) extends Ordered[Rational]{
   2   def compare(that:Rational) = //compareの値が正、負、0のどれかになるかという結果をもとに比較演算子の結果を求めるような仕組みになっている
   3     (this.numer * that.denom) - (that.numer * this.denom) //numerは分子, denomは分母に対応するフィールド
   4 }

   1 abstract class IntQueue {
   2   def get():Int
   3   def put(x:Int)
   4 }
   5 
   6 import scala.collection.mutable.ArrayBuffer
   7 class BasicIntQueue extends IntQueue {
   8   private val buf = new ArrayBuffer[Int] //mutableになっている
   9 
  10   def get() = buf.remove(0)
  11   def put(x:Int){ buf += x } 
  12 }

   1 trait Doubling extends IntQueue {
   2   abstract override def put(x:Int){super.put(2 * x)}
   3 }

   1 class MyQueue extends BasicIntQueue with Doubling
   2 
   3 val queue = new MyQueue
   4 queue.put(10)
   5 queue.get() //20が出てくる
   6 

   1 val queue = new BasicIntQueue with Doubling
   2 queue.put(10)
   3 queue.get() //20が出てくる
   4 

   1 // 待ち行列の値に1加えるトレイト
   2 trait Incrementing extends IntQueue {
   3   abstract override def put(x:int){super.put(x +1)}
   4 }
   5 
   6 // 待ち行列に負の数を加えないようにするトレイト
   7 trait Filtering extends IntQueue {
   8   abstract override def put(x:int){ if(x >= 0) super.put(x)}
   9 }

   1 val queue = new BasicIntQueue with Incrementing with Filtering
   2 
   3 queue.put(-2);queue.put(-1);queue.put(0);
   4 
   5 queue.get() //1が出てくる
   6 
   7 queue.get() //エラー
   8 

   1 class Animal
   2 
   3 trait Furry extends Animal
   4 trait HasLegs extends Animal
   5 trait FourLegged extends HasLegs
   6 
   7 class Cat extends Animal with Furry with FourLegged

   1 Animal→AnyRef→Any //Animalはこのような階層構造になっている
   2 Furry → Animal → AnyRef → Any　//Furryトレイトは次のような構造
   3 Cat→FourLegged→HasLegs→Furry→Animal→AnyRef→Any //Catクラスはこのような構造
   4 

   1 case class Foo(name: String)
   2 val foo = Foo("foo")

   1 case class Foo(name: String)
   2 val foo = new Foo("bar")
   3 foo.name // "bar"
   4 

   1 def hoge(i:Int):String = i match {
   2   case 1 => "1です"
   3   case _ => "1以外です"
   4 }

   1 def printKind(elem: Any) = elem match {
   2     case str: String => println("String") //String型の時
   3     case i: Int => println("Integer") //Int型の時
   4     case _ => println("Other") //その他の時
   5 }

   1 def printKind(elem: Any) = elem match {
   2     case str: String => println("String " + str) //String型の時"String (elemの中身)"
   3     case i: Int => println("Integer " + i) //Int型の時"Integer (elemの中身)"
   4     case _ => println("Other") //その他の時
   5 }

   1 abstract class Expr
   2 
   3 // 変数定義クラス 
   4 case class Var(name:String) extends Expr
   5 // 数値定義クラス
   6 case class Number(num:Double) extends Expr
   7 // 単項演算クラス
   8 case class UnOp(opearator:String, arg:Expr) extends Expr
   9 // 二項演算クラス
  10 case class BinOp(opearator:String, left:Expr, right:Expr) extends Expr

   1 def test(expr:Expr) = expr match {
   2   case BinOp(op, left , right) => println(expr + " は2項演算")
   3   case _ => //何も書かないと何も起きない
   4 }

   1 test(BinOp("+", Number(1), Number(3))) //「BinOp(+,Number(1.0),Number(3.0)) は2項演算」と出力される
   2 
   3 test(UnOp("+", Number(3)))  // 何も出ない
   4 

   1 def test(expr:Expr) = expr match {
   2   case BinOp(_, _ , _) => println(expr + "は2項演算")
   3   case _ => println("2項演算以外")
   4 }