Generics & Givens

case class Box[A](value: A):
  def map[B](f: A => B): Box[B] = Box(f(value))

case class Pair[A, B](first: A, second: B):
  def swap: Pair[B, A] = Pair(second, first)

def firstOr[A](xs: List[A], default: A): A =
  xs.headOption.getOrElse(default)

@main def run(): Unit =
  val b = Box(21)
  println(b.map(_ * 2))
  println(b.map(n => s"#$n"))

  println(Pair("id", 7).swap)

  println(firstOr(List(3, 4), 0))
  println(firstOr(List.empty[String], "none"))
  println(firstOr[Double](Nil, 1.5))

class Animal(val name: String)
class Dog(name: String) extends Animal(name)

trait Source[+A]:
  def next(): A

trait Printer[-A]:
  def print(a: A): String

@main def run(): Unit =
  val dogs: List[Dog] = List(Dog("Rex"), Dog("Bit"))
  val animals: List[Animal] = dogs
  println(animals.map(_.name))

  val dogSource: Source[Dog] = () => Dog("Max")
  val animalSource: Source[Animal] = dogSource
  println(animalSource.next().name)

  val animalPrinter: Printer[Animal] = a => s"animal ${a.name}"
  val dogPrinter: Printer[Dog] = animalPrinter
  println(dogPrinter.print(Dog("Rex")))

trait Entity:
  def id: Int

case class User(id: Int, name: String) extends Entity
case class Product(id: Int, title: String) extends Entity

def byId[A <: Entity](items: List[A], id: Int): Option[A] =
  items.find(_.id == id)

@main def run(): Unit =
  val users = List(User(1, "Asha"), User(2, "Ravi"))
  val u: Option[User] = byId(users, 2)
  println(u.map(_.name))

  val products = List(Product(7, "Kettle"))
  println(byId(products, 7))

sealed trait Stack[+A]:
  def push[B >: A](b: B): Stack[B] = NonEmpty(b, this)

case object Empty extends Stack[Nothing]
case class NonEmpty[+A](top: A, rest: Stack[A]) extends Stack[A]

class Fruit(val name: String):
  override def toString: String = name
class Apple extends Fruit("apple")
class Pear extends Fruit("pear")

@main def run(): Unit =
  val apples: Stack[Apple] = Empty.push(Apple())
  val fruits: Stack[Fruit] = apples.push(Pear())
  println(fruits)

extension (s: String)
  def isPalindrome: Boolean =
    val clean = s.toLowerCase.filter(_.isLetter)
    clean == clean.reverse
  def words: List[String] = s.split("\\s+").toList.filter(_.nonEmpty)
  def truncate(n: Int): String = if s.length <= n then s else s.take(n) + "..."

extension (n: Int)
  def isEven: Boolean = n % 2 == 0
  def times(action: => Unit): Unit = for _ <- 1 to n do action

@main def run(): Unit =
  println("Never odd or even".isPalindrome)
  println("  handbooks   are fun ".words)
  println("Extension methods".truncate(9))
  println(10.isEven)
  3.times(print("hi "))
  println()

object CollectionSyntax:
  extension [A](xs: List[A])
    def second: Option[A] = xs.drop(1).headOption
    def countWhere(p: A => Boolean): Int = xs.count(p)

  extension (xs: List[Int])
    def total: Int = xs.sum

  extension [A](opt: Option[A])
    def orFail(msg: String): Either[String, A] = opt.toRight(msg)

@main def run(): Unit =
  import CollectionSyntax.*
  val xs = List(5, 8, 13)
  println(xs.second)
  println(xs.countWhere(_ > 6))
  println(xs.total)
  println(List("a").second.orFail("no second element"))

trait Show[A]:
  def show(a: A): String

case class Money(cents: Long)

given Show[Int] with
  def show(n: Int): String = s"$n"

given Show[Boolean] with
  def show(b: Boolean): String = if b then "yes" else "no"

given Show[Money] with
  def show(m: Money): String = f"Rs ${m.cents / 100.0}%.2f"

given [A](using s: Show[A]): Show[List[A]] with
  def show(xs: List[A]): String = xs.map(s.show).mkString("[", ", ", "]")

def display[A](label: String, a: A)(using s: Show[A]): Unit =
  println(s"$label: ${s.show(a)}")

@main def run(): Unit =
  display("count", 3)
  display("active", true)
  display("price", Money(12950))
  display("prices", List(Money(100), Money(250)))
  display("flags", List(true, false))

trait Show[A]:
  extension (a: A) def show: String

case class Point(x: Int, y: Int)
object Point:
  given Show[Point] with
    extension (p: Point) def show: String = s"(${p.x}, ${p.y})"

given Show[Int] with
  extension (n: Int) def show: String = s"int $n"

@main def run(): Unit =
  println(Point(2, 3).show)
  println(5.show)
  val s = summon[Show[Point]]
  println(s.show(Point(0, 0)) == Point(0, 0).show)

def maxOf[A: Ordering](xs: List[A]): Option[A] =
  xs.reduceOption((a, b) => if summon[Ordering[A]].gt(a, b) then a else b)

def total[A: Numeric](xs: List[A]): A =
  xs.foldLeft(summon[Numeric[A]].zero)(summon[Numeric[A]].plus)

case class Release(major: Int, minor: Int)
object Release:
  given Ordering[Release] = Ordering.by(r => (r.major, r.minor))

@main def run(): Unit =
  println(maxOf(List(3, 9, 2)))
  println(maxOf(List("pear", "apple")))
  println(total(List(1.5, 2.25)))
  println(total(List(BigInt(10), BigInt(20))))

  val releases = List(Release(2, 13), Release(3, 1), Release(2, 9))
  println(releases.sorted)
  println(maxOf(releases))
  println(releases.sorted(using Ordering[Release].reverse).head)

import scala.language.strictEquality

enum Status derives CanEqual:
  case Active, Suspended

case class UserId(n: Int) derives CanEqual

@main def run(): Unit =
  val s = Status.Active
  println(s == Status.Suspended)
  println(UserId(7) == UserId(7))