Case Classes & Pattern Matching

case class User(name: String, age: Int, role: String = "member")

@main def run(): Unit =
  val a = User("Asha", 30)
  val b = User("Asha", 30)
  println(a)
  println(a == b)
  println(a.name)

  val older = a.copy(age = 31)
  val admin = a.copy(role = "admin")
  println(older)
  println(admin)
  println(a)

  println(Set(a, b, older).size)

sealed trait Payment
case class Card(last4: String, amount: Double) extends Payment
case class Upi(handle: String, amount: Double) extends Payment
case object Cash extends Payment

def describe(p: Payment): String = p match
  case Card(last4, amt) => s"card ending $last4 paid $amt"
  case Upi(handle, amt) => s"UPI $handle paid $amt"
  case Cash             => "paid in cash"

@main def run(): Unit =
  val payments = List(Card("4242", 99.0), Upi("asha@bank", 250.0), Cash)
  payments.map(describe).foreach(println)

case class Rect(w: Int, h: Int)

def classify(x: Any): String = x match
  case 0                     => "zero"
  case "y" | "yes"           => "agreed"
  case n: Int if n < 0       => s"negative int $n"
  case n: Int                => s"int $n"
  case s: String             => s"string of length ${s.length}"
  case (a, 0)                => s"pair ending in zero, first $a"
  case (a, b)                => s"pair $a and $b"
  case Rect(w, h) if w == h  => s"square of side $w"
  case r @ Rect(_, 1)        => s"thin $r"
  case Rect(w, h)            => s"rect ${w * h}"
  case other                 => s"something else: $other"

@main def run(): Unit =
  val inputs = List(0, "yes", -7, 42, "hello", ("k", 0), (1, 2),
    Rect(3, 3), Rect(9, 1), Rect(2, 5), 3.5)
  inputs.foreach(x => println(classify(x)))

def sum(xs: List[Int]): Int = xs match
  case Nil          => 0
  case head :: tail => head + sum(tail)

def describe(xs: List[String]): String = xs match
  case Nil                  => "nobody"
  case List(one)            => one
  case List(a, b)           => s"$a and $b"
  case first :: second :: _ => s"$first, $second and ${xs.length - 2} more"

def firstTwo(xs: List[Int]): String = xs match
  case List(a, b, rest*) => s"$a, $b (+${rest.length})"
  case _                 => "too short"

@main def run(): Unit =
  println(sum(List(3, 4, 5)))
  println(describe(Nil))
  println(describe(List("Asha")))
  println(describe(List("Asha", "Ravi")))
  println(describe(List("Asha", "Ravi", "Meera", "Ken")))
  println(firstTwo(List(9, 8, 7, 6)))
  println(firstTwo(List(1)))

val stock = Map("apple" -> 12, "pear" -> 0)

def check(item: String): String = stock.get(item) match
  case Some(0) => s"$item: sold out"
  case Some(n) => s"$item: $n left"
  case None    => s"$item: we do not sell that"

@main def run(): Unit =
  List("apple", "pear", "kiwi").foreach(i => println(check(i)))

  val parsed = List("7", "x", "35").map(_.toIntOption)
  println(parsed)
  val total = parsed.map {
    case Some(n) => n
    case None    => 0
  }.sum
  println(total)

object Email:
  def unapply(s: String): Option[(String, String)] =
    s.split("@") match
      case Array(user, domain) if user.nonEmpty && domain.contains(".") => Some((user, domain))
      case _ => None

object Even:
  def unapply(n: Int): Boolean = n % 2 == 0

def route(s: String): String = s match
  case Email(user, "example.com") => s"internal user $user"
  case Email(user, domain)        => s"external user $user at $domain"
  case _                          => s"not an email: $s"

@main def run(): Unit =
  List("[email protected]", "[email protected]", "no-at-sign").foreach(s => println(route(s)))
  for n <- List(3, 4) do
    n match
      case Even() => println(s"$n is even")
      case _      => println(s"$n is odd")

enum Plan(val pricePerMonth: Int, val seats: Int):
  case Free       extends Plan(0, 1)
  case Team       extends Plan(49, 10)
  case Enterprise extends Plan(299, 100)

  def pricePerSeat: Double = if seats == 0 then 0 else pricePerMonth.toDouble / seats

@main def run(): Unit =
  for p <- Plan.values do
    println(f"$p%-10s ${p.pricePerMonth}%4d/month  ${p.pricePerSeat}%.2f per seat")

enum Shape:
  case Circle(r: Double)
  case Rect(w: Double, h: Double)
  case Point

import Shape.*

def area(s: Shape): Double = s match
  case Circle(r)  => math.Pi * r * r
  case Rect(w, h) => w * h
  case Point      => 0

@main def run(): Unit =
  val shapes = List(Circle(1), Rect(2, 3), Point)
  shapes.foreach(s => println(f"$s%-14s ${area(s)}%.2f"))
  println(Rect(2, 3) == Rect(2, 3))
  println(Rect(2, 3).copy(h = 10))

case class Order(id: Int, customer: String, total: Double)

@main def run(): Unit =
  val (min, max) = (3, 9)
  println(s"range $min..$max")

  val Order(id, who, _) = Order(7, "Asha", 120.0)
  println(s"order $id by $who")

  val scores = List(("Asha", 91), ("Ravi", 78), ("Meera", 85))
  for (name, score) <- scores do println(s"$name scored $score")

  val passed = scores.collect { case (name, s) if s >= 80 => name.toUpperCase }
  println(passed)

  val mixed: List[Any] = List(1, "two", 3, "four")
  println(mixed.collect { case n: Int => n * 10 })