模式匹配 #

val result = value match
  case pattern1 => result1
  case pattern2 => result2
  case _ => defaultResult

val day = 1

val dayName = day match
  case 1 => "Monday"
  case 2 => "Tuesday"
  case 3 => "Wednesday"
  case 4 => "Thursday"
  case 5 => "Friday"
  case 6 => "Saturday"
  case 7 => "Sunday"
  case _ => "Unknown"

val grade = score match
  case s if s >= 90 => "A"
  case s if s >= 80 => "B"
  case s if s >= 70 => "C"
  case s if s >= 60 => "D"
  case _ => "F"

def describe(x: Any): String = x match
  case 0 => "zero"
  case 1 => "one"
  case true => "true"
  case false => "false"
  case "hello" => "a greeting"
  case _ => "something else"

val result = list match
  case Nil => "empty"
  case _ => "non-empty"

val result = x match
  case 0 => "zero"
  case n => s"non-zero: $n"

val result = list match
  case head :: tail => s"head: $head, rest: $tail"
  case empty @ Nil => s"empty list: $empty"

def describe(x: Any): String = x match
  case i: Int => s"Int: $i"
  case s: String => s"String: $s"
  case d: Double => s"Double: $d"
  case b: Boolean => s"Boolean: $b"
  case list: List[?] => s"List with ${list.length} elements"
  case _ => "Unknown type"

def process(x: Any): String = x match
  case list: List[Int] => "List of Int"
  case list: List[String] => "List of String"
  case _ => "Other"

def describe(arr: Array[?]): String = arr match
  case a: Array[Int] => "Array of Int"
  case a: Array[String] => "Array of String"
  case a: Array[Double] => "Array of Double"
  case _ => "Other array"

val result = x match
  case n if n > 0 => "positive"
  case n if n < 0 => "negative"
  case _ => "zero"

val category = age match
  case a if a < 0 => "invalid"
  case a if a < 13 => "child"
  case a if a < 20 => "teenager"
  case a if a < 65 => "adult"
  case _ => "senior"

val result = (x, y) match
  case (a, b) if a > 0 && b > 0 => "both positive"
  case (a, b) if a < 0 && b < 0 => "both negative"
  case _ => "mixed"

val result = list match
  case Nil => "empty"
  case head :: Nil => s"single element: $head"
  case head :: second :: Nil => s"two elements: $head, $second"
  case head :: tail => s"head: $head, tail length: ${tail.length}"

val result = list match
  case List(1, 2, 3) => "1, 2, 3"
  case List(1, _*) => "starts with 1"
  case List(a, b, c) => s"three elements: $a, $b, $c"
  case _ => "other"

val result = seq match
  case Seq(1, 2, 3) => "exact match"
  case Seq(1, _*) => "starts with 1"
  case Seq(a, b, c, _*) => s"at least three: $a, $b, $c"
  case _ => "other"

val result = tuple match
  case (1, 2) => "tuple (1, 2)"
  case (x, y) => s"tuple ($x, $y)"

val result2 = (a, b, c) match
  case (1, _, 3) => "first is 1, third is 3"
  case (x, y, z) => s"($x, $y, $z)"

case class Person(name: String, age: Int)

val person = Person("Alice", 25)

val result = person match
  case Person("Alice", _) => "It's Alice"
  case Person(name, age) if age < 18 => s"$name is a minor"
  case Person(name, age) => s"$name is $age years old"

case class Address(city: String, country: String)
case class Person(name: String, address: Address)

val person = Person("Alice", Address("Beijing", "China"))

val result = person match
  case Person(name, Address("Beijing", _)) => s"$name lives in Beijing"
  case Person(name, Address(_, "China")) => s"$name lives in China"
  case Person(name, _) => s"$name lives somewhere"

case class Point(x: Int, y: Int)

val point = Point(10, 20)

val result = point match
  case Point(0, 0) => "origin"
  case Point(x, 0) => s"on x-axis at $x"
  case Point(0, y) => s"on y-axis at $y"
  case Point(x, y) => s"at ($x, $y)"

val result = opt match
  case Some(value) => s"value: $value"
  case None => "no value"

val result = nestedOpt match
  case Some(Some(value)) => s"nested value: $value"
  case Some(None) => "inner is None"
  case None => "outer is None"

def getOrElse(opt: Option[String], default: String): String = opt match
  case Some(value) => value
  case None => default

def mapOption[A, B](opt: Option[A])(f: A => B): Option[B] = opt match
  case Some(value) => Some(f(value))
  case None => None

val result = either match
  case Right(value) => s"success: $value"
  case Left(error) => s"error: $error"

def process(result: Either[String, Int]): String = result match
  case Right(n) if n > 0 => s"positive: $n"
  case Right(n) if n < 0 => s"negative: $n"
  case Right(0) => "zero"
  case Left(msg) => s"error: $msg"

sealed trait Animal
case class Dog(name: String) extends Animal
case class Cat(name: String) extends Animal
case object Bird extends Animal

def describe(animal: Animal): String = animal match
  case Dog(name) => s"Dog named $name"
  case Cat(name) => s"Cat named $name"
  case Bird => "A bird"

object Even:
  def unapply(n: Int): Option[Int] =
    if n % 2 == 0 then Some(n / 2) else None

val result = 10 match
  case Even(half) => s"Even number, half is $half"
  case _ => "Odd number"

object Domain:
  def unapply(url: String): Option[(String, String)] =
    val parts = url.split("\\.")
    if parts.length >= 2 then
      Some((parts.init.mkString("."), parts.last))
    else
      None

val result = "www.scala-lang.org" match
  case Domain(name, tld) => s"Domain: $name, TLD: $tld"
  case _ => "Invalid URL"

object Positive:
  def unapply(n: Int): Boolean = n > 0

val result = x match
  case Positive() => "positive"
  case _ => "non-positive"

sealed trait Result
case class Success(value: Int) extends Result
case class Failure(message: String) extends Result

def handle(result: Result): String = result match
  case Success(value) => s"Success: $value"
  case Failure(msg) => s"Failure: $msg"

val result = data match
  case Some(value) => value match
    case Success(x) => s"ok: $x"
    case Failure(e) => s"error: $e"
  case None => "no data"

val result2 = data match
  case Some(Success(x)) => s"ok: $x"
  case Some(Failure(e)) => s"error: $e"
  case None => "no data"

val result = x match
  case n if n > 0 => "positive"
  case n if n < 0 => "negative"
  case _ => "zero"