Scala 类型系统实战：泛型、ADT、协变逆变与类型类

// 类型声明就说明了一切
def processOrder(orderId: Long): Either[OrderError, Order]
// 读签名即知：可能失败、失败带原因、成功返回 Order

// ❌ 用 Boolean 表达状态：可漏
def validate(x: Int): Boolean

// ✅ 用密封类型：状态穷尽
sealed trait ValidationResult
case object Valid extends ValidationResult
case class Invalid(reason: String) extends ValidationResult

case class Box[A](value: A)

val intBox: Box[Int]    = Box(42)
val strBox: Box[String] = Box("hello")

def headOr[A](list: List[A], default: A): A =
  list.headOption.getOrElse(default)

headOr(List(1,2), 0)     // 1
headOr(List.empty, 0)    // 0

// 约束 A 必须有序，才能 max
def maxOf[A: Ordering](list: List[A]): A =
  list.max

// 约束 A 是 Number 的子类
def sumNumbers[A <: Number](list: List[A]): Double =
  list.map(_.doubleValue).sum

sealed trait Payment
case class Card(number: String, exp: String) extends Payment
case class BankTransfer(account: String)     extends Payment
case object Cash                              extends Payment

def fee(p: Payment): Double = p match {
  case Card(_, _)             => 0.5
  case BankTransfer(_)        => 1.0
  case Cash                    => 0.0
  // sealed + match 穷尽：少一个 case 编译报错
}

case class Order(id: Long, items: List[Item])

// 自动：equals/hashCode/toString/copy/解构/构造器
val o1 = Order(1, Nil)
val o2 = o1.copy(id = 2)       // 复制并改部分字段
val Order(id, items) = o2      // 解构

val orders = List(Order(1, List("a")), Order(2, Nil))
orders.collect {
  case Order(id, items) if items.nonEmpty => s"订单$id 有商品"
}

// List 是协变的：List[Int] <: List[AnyVal]
val ints: List[Int] = List(1, 2)
val anys: List[AnyVal] = ints    // ✅ 合法

// Array 是不变的：不能这样赋值
val arrInt: Array[Int] = Array(1)
// val arrAny: Array[AnyVal] = arrInt  // ❌ 编译错误

// 若 Array 协变：
val arrInt: Array[Int] = Array(1)
val arrAny: Array[AnyVal] = arrInt   // 假想合法
arrAny(0) = "hello"                  // 把字符串放进 Int 数组 → 运行崩溃
// 所以 Scala 让 Array 不变，编译期就拦住

// A 必须是 Animal 的子类型
def feed[A <: Animal](a: A): Unit = a.eat()

// 协变容器里写值要用下界避免类型漏洞
class Container[+A](private val value: A) {
  def set[B >: A](newVal: B): Container[B] = new Container[B](newVal)
}

// 经典案例：排序时允许更宽的类型
def sortPets[A <: Pet](pets: List[A]): List[A] = ...

// OO 方式：类型自身实现方法
trait JsonSerializable { def toJson: String }
case class User(n: String) extends JsonSerializable

// 类型类方式：行为与类型分离，可扩展已有类型
trait JsonWriter[A] { def write(a: A): String }

given userWriter: JsonWriter[User] = u => s"""{"name":"${u.n}"}"""
given intWriter: JsonWriter[Int] = i => i.toString

def toJsonString[A](a: A)(using w: JsonWriter[A]): String =
  w.write(a)

toJsonString(User("alice"))   // 自动找 given userWriter
toJsonString(42)              // 自动找 given intWriter

// Circe：JSON 编解码的类型类
import io.circe._, io.circe.syntax._
val json = User("alice").asJson   // 自动编码

class Database {
  class Connection
  def connect: Connection = new Connection
}

val db1 = new Database
val db2 = new Database
// db1.Connection 与 db2.Connection 是不同类型
// val c: db2.Connection = db1.connect  // ❌ 类型不匹配