Type classes

trait DiscountStrategy {
  def apply(price: Int): Int
}

def applyDiscounts(
    item: Item, // case class Item(name: String, price: Int)
    quantity: Int,
    discount: Option[DiscountStrategy]
): (Int, Int) = {
  val price = item.price * quantity
  val discounted = discount.fold(price)(_.apply(price))
  (price, discounted)
}

// in Java it would be:
// interface Show<A> { ... }
trait Show[A] {
  def show(a: A): String
}

def show[A](value: A)(show: Show[A]): String =
  show.show(value)

class Example(val fiels: String)

val example: Example = new Example("test")

val showExample: Show[Example] =
  // Single Abstract Method syntax:
  // creates new Show[Example] { ... }
  // as if it was a function
  value => s"Example(${value.field})"

show(example)(showExample)

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

extension [A](value: A)
  def show(using show: Show[A]): String = show.show(value)

class Example(val fiels: String)
val example: Example = new Example("test")

given showExample: Show[Example] =
  value => s"Example(${value.field})"

example.show(using showExample)

example.show // showExample is passed for us

given Show[Example] =
  value => s"Example(${value.field})"

example.show // anonymous Show[Example] is passed for us

given Show[String] = str => '"' + str + '"'
given Show[Int] = int => int.toString

given [A](using A: Show[A]): Show[Array[A]] = arr =>
  s"Array(${arr.map(_.show).mkString(", ")})"

given [A, B](using A: Show[A], B: Show[B]): Show[(A, B)] = {
  case (a, b) =>
    s"Tuple2(${a.show}, ${b.show})"
}