上下文界定 #

def max[T](a: T, b: T)(using ord: Ordering[T]): T =
  if ord.compare(a, b) > 0 then a else b

def max[T: Ordering](a: T, b: T): T =
  val ord = summon[Ordering[T]]
  if ord.compare(a, b) > 0 then a else b

def sort[T: Ordering](list: List[T]): List[T] =
  list.sorted

def max[T: Ordering](a: T, b: T): T =
  if summon[Ordering[T]].compare(a, b) > 0 then a else b

sort(List(3, 1, 4, 1, 5))
max("hello", "world")

def process[T: Show](value: T): String =
  summon[Show[T]].show(value)

def process[T: Ordering: Show](value: T): String =
  val show = summon[Show[T]]
  val ord = summon[Ordering[T]]
  show.show(value)

trait Show[T]:
  def show(value: T): String

trait Eq[T]:
  def eqv(a: T, b: T): Boolean

trait Monoid[T]:
  def empty: T
  def combine(a: T, b: T): T

given Show[Int] with
  def show(value: Int): String = value.toString

given Show[String] with
  def show(value: String): String = value

given Show[Boolean] with
  def show(value: Boolean): String = value.toString

given Monoid[Int] with
  def empty: Int = 0
  def combine(a: Int, b: Int): Int = a + b

given Monoid[String] with
  def empty: String = ""
  def combine(a: String, b: String): String = a + b

def printShow[T: Show](value: T): Unit =
  println(summon[Show[T]].show(value))

def combineAll[T: Monoid](list: List[T]): T =
  list.foldLeft(summon[Monoid[T]].empty)(summon[Monoid[T]].combine)

printShow(42)
printShow("hello")
combineAll(List(1, 2, 3, 4, 5))
combineAll(List("a", "b", "c"))

def max[T <% Ordered[T]](a: T, b: T): T =
  if a > b then a else b

def max[T: Ordering](a: T, b: T): T =
  val ord = summon[Ordering[T]]
  if ord.compare(a, b) > 0 then a else b

def max[T](a: T, b: T)(using ord: Ordering[T]): T =
  given Conversion[T, Ordered[T]] = x => Ordered.orderingToOrdered(x)
  if a > b then a else b

def firstOf[A, B <: A](list: List[B]): Option[A] =
  list.headOption

def addTo[A, B >: A](list: List[A], item: B): List[B] =
  item :: list

trait Comparable[T]:
  def compare(a: T, b: T): Int

def max[T](a: T, b: T)(using comp: Comparable[T]): T =
  if comp.compare(a, b) > 0 then a else b

def process[T: Show: Ordering](value: T, other: T): String =
  val show = summon[Show[T]]
  val ord = summon[Ordering[T]]
  val comparison = ord.compare(value, other)
  s"${show.show(value)} vs ${show.show(other)}: $comparison"

trait JsonWriter[T]:
  def write(value: T): String

object JsonWriter:
  given JsonWriter[Int] with
    def write(value: Int): String = value.toString
  
  given JsonWriter[String] with
    def write(value: String): String = s""""$value""""
  
  given JsonWriter[Boolean] with
    def write(value: Boolean): String = value.toString
  
  given [T: JsonWriter]: JsonWriter[List[T]] with
    def write(value: List[T]): String =
      value.map(summon[JsonWriter[T]].write).mkString("[", ", ", "]")
  
  given [T: JsonWriter]: JsonWriter[Option[T]] with
    def write(value: Option[T]): String =
      value.map(summon[JsonWriter[T]].write).getOrElse("null")

def toJson[T: JsonWriter](value: T): String =
  summon[JsonWriter[T]].write(value)

import JsonWriter.given

toJson(42)
toJson("hello")
toJson(List(1, 2, 3))
toJson(Option("value"))

trait Database[T]:
  def findById(id: Long): Option[T]
  def save(entity: T): T
  def delete(id: Long): Unit

def withEntity[T: Database, R](id: Long)(f: T => R): Option[R] =
  summon[Database[T]].findById(id).map(f)

given Database[User] with
  def findById(id: Long): Option[User] = ???
  def save(entity: User): User = ???
  def delete(id: Long): Unit = ???

withEntity[User, String](1L)(_.name)

trait ConfigReader[T]:
  def read(value: String): Option[T]

object ConfigReader:
  given ConfigReader[Int] with
    def read(value: String): Option[Int] = value.toIntOption
  
  given ConfigReader[String] with
    def read(value: String): Option[String] = Some(value)
  
  given ConfigReader[Boolean] with
    def read(value: String): Option[Boolean] =
      value.toLowerCase match
        case "true" | "yes" | "1" => Some(true)
        case "false" | "no" | "0" => Some(false)
        case _ => None

def getConfig[T: ConfigReader](key: String)(using map: Map[String, String]): Option[T] =
  map.get(key).flatMap(summon[ConfigReader[T]].read)

given Map[String, String] = Map(
  "port" -> "8080",
  "host" -> "localhost",
  "debug" -> "true"
)

getConfig[Int]("port")
getConfig[String]("host")
getConfig[Boolean]("debug")

def process[T: Show](value: T): String =
  summon[Show[T]].show(value)

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

object Person:
  given Show[Person] with
    def show(value: Person): String = s"${value.name} (${value.age})"

extension [T: Show](value: T)
  def show: String = summon[Show[T]].show(value)

42.show
"hello".show