「デフォルト引数」および「Unit 型を返す関数」

object HelloWorld {
  def main(args: Array[String]): Unit = {
    def myPrint(myArg: String = "default_value") = println(myArg + "!")
    val result = myPrint() //=> default_value!
    println(result) //=> ()  ← 他言語で void を意味する Unit 型

    // 後述の「名前付きで引数を指定」と併用すると、第 N 引数のみを省略できる
    def func(arg1: String = "abc", arg2: Int = 123): Unit = {
      println("arg1 = %s, arg2 = %d" format (arg1, arg2))
    }
    func(arg2 = 999) //=> arg1 = abc, arg2 = 999
  }
}

名前付きで引数を指定

object HelloWorld {
  def main(args: Array[String]): Unit = {
    def myFunc(a: Int, b: Int): Unit = {
      println("a = %d, b = %d" format (a, b))
    }
    myFunc(b = 2, a = 1) //=> a = 1, b = 2
  }
}

可変長引数

object HelloWorld {
  def main(args: Array[String]): Unit = {
    def myFunc(str: String, arg: Int*) = {
      var i = 0;
      val len = arg.length
      while(i < len) {
        println(str + arg(i))
        i += 1
      }
    }
    myFunc("hi", 1,2,3) //=> hi1 => hi2 => hi3
  }
}

複数の値を返す

タプルを利用します。

object HelloWorld {
  def main(args: Array[String]): Unit = {
    def func: (Int, String) = {
      return (123, "abc")
    }
    println(func) //=> (123,abc)
  }
}

制御構造ブロックを引数として渡す

object HelloWorld {
  def main(args: Array[String]): Unit = {
    def myFunc(a: Int) = {
      println(a)
    }
    myFunc {
      val a = 1
      val b = 2
      a + b
    }
  }
}

無名関数

object HelloWorld {
  def main(args: Array[String]): Unit = {
    // 無名関数
    val f = (i: Int) => {
      i * 2
    }
    println(f(1)) //=> 2

    // 無名関数化
    def func(str: String): Int = {
      str.size
    }
    val f2: (String) => Int = func
    println(f2("hi")) //=> 2
  }
}

関数を引数または返り値にとる関数

object HelloWorld {
  def main(args: Array[String]): Unit = {
    // 関数を返す関数
    def func(): (String) => Int = {
      (str: String) => {
        str.size
      }
    }
    println(func()("hi")) //=> 2

    // 関数を引数にとる関数
    def func2(f: (String) => Int, str: String): Int = {
      f(str)
    }
    println(
      func2(((str: String) => { str.size }), "hi") //=> 2
    )
  }
}

クロージャ

object HelloWorld {
  def main(args: Array[String]): Unit = {
    def func(i: Int): (String) => Int = {
      (str: String) => {
        str.size + i
      }
    }
    println(func(1)("hi")) //=> 3
    println(func(2)("hi")) //=> 4
  }
}

引数の一部を固定した関数を生成

object HelloWorld {
  def main(args: Array[String]): Unit = {
    def func3(i: Int, j: Int): Unit = {
      println(i + j)
    }
    val f1 = func3(1, _: Int)
    val f2 = func3(_: Int, 1)
    f1(1) //=> 2
    f2(1) //=> 2
  }
}

関数をローカル関数で分割して読み易くする

object HelloWorld {
  def main(args: Array[String]): Unit = {
    def func(i: Int): Unit = {
      def innerFunc: Int = {
        i*1
      }
      def innerFunc2: Int = {
        i*10
      }
      val x = innerFunc
      val y = innerFunc2
      println(x + y) //=> 11
    }
    func(1)
  }
}

カリー化

「引数が複数ある関数」を「引数がひとつの関数のチェーン」に変換することで、関数を引数にとる関数を可読性よく利用できます。

object HelloWorld {
  def main(args: Array[String]): Unit = {
    // カリー化
    def func(i: Int)(j: Int): Unit = {
      println(i + j)
    }
    val f = (i: Int) => (j: Int) => {
      println(i + j)
    }
    func(1)(2) //=> 3
    val tmp = func(1)_
    tmp(2) //=> 3
    f(1)(2) //=> 3

    // 既存の関数をカリー化
    def func2(i: Int, j: Int): Unit = {
      println(i + j)
    }
    val f2 = (i: Int, j: Int) => {
      println(i + j)
    }
    val f3 = (func2 _).curried
    val f4 = f2.curried
    f3(1)(2) //=> 3
    f4(1)(2) //=> 3

    // 関数を引数にとる関数をスマートに利用
    // 関数に `{}` を引数として渡せることを利用しています。上記「制御構造ブロックを引数として渡す」をご参照ください。
    def func3(str: String)(f: (String) => Int) = {
      f(str)
    }
    println( //=> 2
      func3("hi"){ str =>
        str.size
      }
    )
  }
}

引数のパターンマッチ

object HelloWorld {
  def main(args: Array[String]): Unit = {
    def func: (String) => Unit = {
      case "abc" => {
        println("hi")
      }
      case x => {
        println(x)
      }
    }
    func("abc") //=> hi
  }
}