Scala match

• 概要 [/2017-01-29]
• 数値のマッチング [/2017-01-31]
• match式の値 [/2020-10-01]
• 数値以外のマッチング [/2011-02-27]
• 型のマッチング [/2011-08-15]
• マッチした値の取得 [/2017-01-29]
• ガード条件（if） [/2017-01-29]
• matchの省略 [/2017-02-02]
• unapply・unapplySeq [/2017-01-29]

• Scala構文全般
• 部分関数（PartialFunction）
• 変数定義時のパターンマッチ

• Javaのswitch文

• 参考書

var n = 1

n match {
  case 1 => println("いち")
  case 2 => println("に")
  case 3 => println("さん")
  case _ => println("たくさん")
}

int n = 1;

switch(n) {
case 1:  System.out.println("いち");     break;
case 2:  System.out.println("に");       break;
case 3:  System.out.println("さん");     break;
default: System.out.println("たくさん"); break;
}

var n = 1

n match {
  case 1 =>
    println("いち")

  case 2 =>
    println("に")

  case 3 =>
    println("さん")

  case _ =>
    println("たくさん")

}

int n = 1;

switch(n) {
case 1:
    System.out.println("いち");
    break;
case 2:
    System.out.println("に");
    break;
case 3:
    System.out.println("さん");
    break;
default:
    System.out.println("たくさん");
    break;
}

n match {
  case 1 =>
  case 2 =>
  case _ => error("hoge")
}

switch(n) {
  case 1:  break;
  case 2:  break;
  default: throw new RuntimeException("hoge");
}

n match {
  case 1 | 2 | 3 =>
    println("数えられる");
  case _ =>
    println("数えられない");
}

switch(n) {
case 1:
case 2:
case 3:
    System.out.println("数えられる");
    break;
default:
    System.out.println("数えられない");
    break;
}

def nullCheck(s: String) = {
  s match {
    case null => 0
    case _    => 1 
  }
}

def str(s: String) = {
  s match {
    case "abc" => 1
    case "def" => 2
    case "ghi" => 3
  }
}

int str(String s) {

  if ("abc".equals(s)) { return 1; } else
  if ("def".equals(s)) { return 2; } else
  if ("ghi".equals(s)) { return 3; } else
  throw new MatchError(s);
}

def arr(a: Array[Int]) = {
  a match {
    case Array(1,2,3) => 1
    case Array(4,5,6) => 2
  }

}

int arr(int[] a) {
  if(a != null && a.length == 3) {
    if (a[0]==1 && a[1]==2 && a[2]==3) { return 1; } else
    if (a[0]==4 && a[1]==5 && a[2]==6) { return 2; }
  }
  throw new MatchError(a);
}

def tup(t: (Int, String)) = {
  t match {
    case (1,"abc") => 11
    case (2,"abc") => 21
    case (1,"def") => 12
    case (2,"def") => 22
  }
}

int tup(Tuple2 t) {
  if (t != null) {
    int    n = (Integer)t._1();
    String s = (String) t._2();
    switch(n) {
    case 1:
      if ("abc".equals(s)) { return 11; } else
      if ("def".equals(s)) { return 12; }
      break;
    case 2:
      if ("abc".equals(s)) { return 21; } else
      if ("def".equals(s)) { return 22; }
      break;
    }
  }
  throw new MatchError(t);
}

def tup(obj: Any) = {
  obj match {
    case (1, _) => "tup2-1"
    case (2, _) => "tup2-2"
    case (_, 3) => "tup2-3"
    case (_, _, _) => "tup3"
  }
}

def list(l: List[_]) = {
  l match {
    case List(1, _*) => "one"
    case List(2, _*) => "two"
  }
}

def size(value: Int) = {
  value match {
    case 1 => "tiny"
    case 2 => "small"
    case n => n.toString
  }
}

def opt(option: Option[String]) = {
  option match {
    case Some(s) => s
    case _       => "empty"
  }
}

def tup(obj: Any) = {
  obj match {
    case (1, s)    => "one " + s
    case (2, s)    => "two " + s
    case (_, s, _) => "tup3 " + s
  }
}

def tup(obj: Any) = {
  obj match {
    case t @ (_,b)   => t + "=" + b
    case t @ (_,_,c) => t + "=" + c
  }
}

def length(obj: Any) = {
  obj match {
    case s:String   => s.length


    case a:Array[_] => a.length


    case l:List[_]  => l.size


  }
}

int length(Object obj) {

  if (obj instanceof String) {
    final String s = (String)obj; return s.length();
  }
  if (ScalaRunTime.isArray(obj,1)) {
    return ScalaRuntime.array_length(obj);
  }
  if (obj instanceof List)   {
    final List<?> l = (List<?>)obj; return l.size();
  }
  throw new MatchError(obj);
}

def list(l: List[_]) = {
  l match {
    case List(n, other @ _*) =>
      println(n)
      println(other)
  }
}

val re = """(.+)=(.+)""".r
def regexp(s: String) = {
  s match {
    case re(k,v) => (k,v)
    case _       => ("","")
  }
}

scala> regexp("key=val")
res44: (String, String) = (key,val)

def count(n: Int) = {
  n match {
    case m if m <  0 => "なにそれ"
    case 0           => "ない"
    case m if m <= 3 => "数えられる"
    case _           => "たくさん"
  }
}

def number(obj: Any) = {
  obj match {
    case n:Int                => "int=" + n
    case n:Long if n < 65536L => "小long=" + n
    case n:Long               => "大long=" + n
  }
}

def check(s: String) = {
  s match {
    case s if s ne null => s
    case _              => "empty"
  }
}

  Option(s) match {
    case Some(s) => s
    case _       => "empty"
  }

  Option(s).getOrElse("empty")

  s match {
    case null => "empty"
    case s    => s
  }

def count(n: Int) = {
  n match {
    case 1 => "one"
    case 2 => "two"
  }
}

def count(n: Int) = n match {
  case 1 => "one"
  case 2 => "two"
}

seq.map(n => n match {
  case 1 => "one"
  case 2 => "two"
})

seq.map(_ match {
  case 1 => "one"
  case 2 => "two"
})

seq.map {
  case 1 => "one"
  case 2 => "two"
}

var f: (Int) => String = null

f = (n: Int) => {
  n match {
    case 1 => "one"
    case 2 => "two"
  }
}

var f: (Int) => String = null

f = {
  _ match {
    case 1 => "one"
    case 2 => "two"
  }
}

f = {
  case 1 => "one"
  case 2 => "two"
}

val f = (n: Int) => {
  n match {
    case 1 => "one"
    case 2 => "two"
  }
}

val f: (Int) => String = {
  case 1 => "one"
  case 2 => "two"
}

val f = {
  case 1 => "one"
  case 2 => "two"
}: ((Int) => String)

def call1(f: (Int) => String) = {
  f(1)
}

call1({ (n) =>
  n match {
    case 1 => "one"
    case 2 => "two"
  }
})

def call1(f: (Int) => String) = {
  f(1)
}

call1({
  case 1 => "one"
  case 2 => "two"
})


//引数が1個の場合は()の代わりに{}を使用可
call1{
  case 1 => "one"
  case 2 => "two"
}

def call2(f: (Int, Int) => Int) = {
  f(1, 0)
}

call2({ (a, b) =>
  (a, b) match {
    case (1, _) => 11
    case (_, 2) => 22
  }
})

def call2(f: (Int, Int) => Int) = {
  f(1, 0)
}

call2({
  case (1, _) => 11
  case (_, 2) => 22
})


//引数が1個の場合は()の代わりに{}を使用可
call2{
  case (1, _) => 11
  case (_, 2) => 22
}

object MyCase {
  def unapply(a: Any): Boolean = {
    a.isInstanceOf[Int]
  }
}

val n = 123
//val n = 123L

n match {
  case MyCase() => "match"
  case _        => "orz"
}

val n = 123
//val n = 123L

if (MyCase.unapply(n)) {
  "match"
} else {
  "orz"
}

object MyCase {
  def unapply(a: Any): Option[Int] = {
    if (a.isInstanceOf[Int]) {
      Some(a.asInstanceOf[Int])
    } else {
      None
    }
  }
}

val obj = 123

obj match {
  case MyCase(n) => n
  case _ => 0
}

val obj = 123

val opt = MyCase.unapply(obj)
if (opt.isDefined) {
  opt.get
} else {
  0
}

object MyCase {
  def unapply(a: Any) = {
    if (a.isInstanceOf[Int]) {
      Some((a.asInstanceOf[Int], "int"))
    } else {
      None
    }
  }
}

val obj = 123

obj match {
  case MyCase(n, s) => s+n
  case _ => "none"
}

val obj = 123

val opt = MyCase.unapply(obj)
if (opt.isDefined) {
  val (n, s) = opt.get
  s+n
} else {
  "none"
}

obj match {
  case MyCase(_, s) => s
  case _ => "none"
}

val opt = MyCase.unapply(obj)
if (opt.isDefined) {
  val t = opt.get
  val s = t._2
  s
} else {
  "none"
}

object MyCase {
  def unapplySeq(a: Any) = {
    if (a.isInstanceOf[Int]) {
      Some(Seq(a.asInstanceOf[Int],22,33))
    } else {
      None
    }
  }
}

val obj = 123

obj match {
  case MyCase(n1,n2,n3) =>
    n1+n2+n3
  case _ => 0
}

val obj = 123

val opt = MyCase.unapplySeq(obj)
val s = opt.getOrElse(Seq())
if (s.size == 3) {
  val i = s.iterator
  val n1 = i.next
  val n2 = i.next
  val n3 = i.next
  n1+n2+n3
} else {
  0
}

obj match {
  case MyCase(n1, _*) =>
    n1
  case _ => 0
}

val opt = MyCase.unapplySeq(obj)
val s = opt.getOrElse(Seq())
if (s.size >= 1) {
  val n1 = s.head
  n1
} else {
  0
}