代数数据类型

// 一个网络请求的结果，要么成功，要么失败——这就是典型的 Sum 类型
// A network result is EITHER success OR failure - a classic Sum Type
sealed class NetworkResult<out T> {
    // 成功分支：携带数据
    data class Success<T>(val data: T) : NetworkResult<T>()
    // 失败分支：携带错误信息
    data class Failure(val error: String) : NetworkResult<Nothing>()
    // 加载中分支：无额外数据
    data object Loading : NetworkResult<Nothing>()
}
 
// 使用时必须处理所有可能的情况（穷尽性检查）
fun <T> handleResult(result: NetworkResult<T>) {
    when (result) {
        is NetworkResult.Success -> println("数据: ${result.data}")
        is NetworkResult.Failure -> println("错误: ${result.error}")
        is NetworkResult.Loading -> println("加载中...")
        // 编译器确保所有分支都被处理，遗漏会报错
    }
}

// 更简单的例子：布尔类型本质上就是最简单的 Sum 类型
// Boolean is essentially the simplest Sum Type: True + False = 2 possible values
enum class MyBoolean {
    TRUE,   // 1 种可能
    FALSE   // 1 种可能
}
// 总计：1 + 1 = 2 种可能的值

// 一个用户信息，同时包含姓名和年龄——这就是典型的 Product 类型
// User contains BOTH name AND age - a classic Product Type
data class User(
    val name: String,    // 字段1：姓名
    val age: Int         // 字段2：年龄
)
 
// 坐标点：同时拥有 x 和 y 两个维度
data class Point(
    val x: Double,       // 横坐标
    val y: Double        // 纵坐标
)

// 假设一个简化的场景来理解"积"的含义
// Simplified example to understand "Product"
data class SimplePair(
    val first: Boolean,  // 2 种可能 (true/false)
    val second: Boolean  // 2 种可能 (true/false)
)
// 总计：2 × 2 = 4 种可能的组合
// (true, true), (true, false), (false, true), (false, false)

┌─────────────────────────────────────────────────────────────┐
│              Product 类型的组合爆炸示意                       │
├─────────────────────────────────────────────────────────────┤
│  data class Config(                                         │
│      val darkMode: Boolean,    // 2 种                      │
│      val fontSize: Size,       // 3 种 (SMALL/MEDIUM/LARGE) │
│      val language: Lang        // 4 种 (ZH/EN/JP/KR)        │
│  )                                                          │
│                                                             │
│  可能的配置组合数 = 2 × 3 × 4 = 24 种                         │
│  (Number of possible configurations = 2 × 3 × 4 = 24)       │
└─────────────────────────────────────────────────────────────┘

// Nothing：零类型，不存在任何实例
// Nothing: The zero type - no instances can exist
fun impossible(): Nothing {
    throw IllegalStateException("此函数永远不会正常返回")
}
 
// Unit：单位类型，只有一个实例
// Unit: The unit type - exactly one instance
fun doSomething(): Unit {
    println("执行操作")
    // 隐式返回 Unit
}
 
// 函数类型的代数解释
// (Boolean) -> Boolean 有多少种可能的实现？
// 输入有 2 种可能，每种输入可以映射到 2 种输出
// 所以总共有 2^2 = 4 种不同的函数实现
val f1: (Boolean) -> Boolean = { true }           // 常量 true
val f2: (Boolean) -> Boolean = { false }          // 常量 false
val f3: (Boolean) -> Boolean = { it }             // 恒等函数
val f4: (Boolean) -> Boolean = { !it }            // 取反函数

// 代数恒等式：A × 1 = A
// 类型对应：Pair<A, Unit> ≅ A（同构）
data class WithUnit<A>(val value: A, val unit: Unit)
// 这个类型本质上和单独的 A 没有区别，因为 Unit 不携带任何信息
 
// 代数恒等式：A × 0 = 0
// 类型对应：Pair<A, Nothing> ≅ Nothing
// 如果一个 Product 类型的某个字段是 Nothing，那么整个类型就不可能有实例
 
// 代数恒等式：A + 0 = A
// 类型对应：Either<A, Nothing> ≅ A
// 如果 Sum 类型的某个分支是 Nothing，那个分支永远不会被使用

data class Person(
    val name: String,      // 对应 component1()
    val age: Int,          // 对应 component2()
    val email: String      // 对应 component3()
)
 
fun main() {
    val person = Person("张三", 25, "zhangsan@example.com")
    
    // 手动调用组件函数（通常不这样用，但可以）
    val name = person.component1()   // "张三"
    val age = person.component2()    // 25
    val email = person.component3()  // "zhangsan@example.com"
    
    println("$name, $age, $email")
}

// 这是编译器自动生成的，我们不需要手写
// This is auto-generated by the compiler
class Person(val name: String, val age: Int, val email: String) {
    
    // 组件函数：返回对应位置的属性值
    operator fun component1(): String = name
    operator fun component2(): Int = age
    operator fun component3(): String = email
    
    // ... 还有其他生成的方法
}

// 危险示例：重构导致的隐蔽 Bug
// Dangerous: Refactoring can cause subtle bugs
 
// 原始版本
data class Coordinate(val x: Int, val y: Int)
val (x, y) = Coordinate(10, 20)  // x=10, y=20 ✓
 
// 重构后（交换了 x 和 y 的位置）
data class Coordinate(val y: Int, val x: Int)  // 顺序变了！
val (x, y) = Coordinate(10, 20)  // x=10, y=20 ✗ 实际上 x 拿到的是 y 的值！

data class Rectangle(
    val width: Int,
    val height: Int,
    val color: String
)
 
fun main() {
    val rect = Rectangle(100, 50, "red")
    
    // 解构声明：一次性提取多个属性
    // Destructuring: Extract multiple properties at once
    val (width, height, color) = rect
    
    // 上面这行代码等价于：
    // val width = rect.component1()
    // val height = rect.component2()
    // val color = rect.component3()
    
    println("宽: $width, 高: $height, 颜色: $color")
    // 输出: 宽: 100, 高: 50, 颜色: red
}

// 普通类通过定义 operator 函数支持解构
// Regular class can support destructuring via operator functions
class Temperature(private val celsius: Double) {
    
    // 第一个组件：摄氏度
    operator fun component1(): Double = celsius
    
    // 第二个组件：华氏度（计算得出）
    operator fun component2(): Double = celsius * 9 / 5 + 32
    
    // 第三个组件：开尔文（计算得出）
    operator fun component3(): Double = celsius + 273.15
}
 
fun main() {
    val temp = Temperature(25.0)
    
    // 解构获取三种温度单位
    val (celsius, fahrenheit, kelvin) = temp
    
    println("摄氏: $celsius°C")      // 25.0°C
    println("华氏: $fahrenheit°F")   // 77.0°F
    println("开尔文: $kelvin K")     // 298.15 K
}

data class User(
    val id: Long,
    val name: String,
    val email: String,
    val isActive: Boolean = true
)
 
fun main() {
    val user1 = User(1, "张三", "zhangsan@example.com")
    
    // 使用 copy 创建一个新对象，只修改指定的属性
    // Create a new object with copy, modifying only specified properties
    val user2 = user1.copy(name = "李四")
    val user3 = user1.copy(email = "new@example.com", isActive = false)
    
    println(user1)  // User(id=1, name=张三, email=zhangsan@example.com, isActive=true)
    println(user2)  // User(id=1, name=李四, email=zhangsan@example.com, isActive=true)
    println(user3)  // User(id=1, name=张三, email=new@example.com, isActive=false)
    
    // 原对象不变，这就是不可变性的体现
    // Original object unchanged - this is immutability
    println(user1 === user2)  // false，是不同的对象
}

// 编译器自动生成，所有参数都有默认值（取自当前对象）
fun copy(
    id: Long = this.id,
    name: String = this.name,
    email: String = this.email,
    isActive: Boolean = this.isActive
): User = User(id, name, email, isActive)

data class Team(
    val name: String,
    val members: MutableList<String>  // 可变列表
)
 
fun main() {
    val team1 = Team("开发组", mutableListOf("张三", "李四"))
    val team2 = team1.copy(name = "测试组")
    
    // 浅拷贝：两个 Team 共享同一个 members 列表！
    // Shallow copy: Both teams share the same members list!
    team2.members.add("王五")
    
    println(team1.members)  // [张三, 李四, 王五] ← team1 也被影响了！
    println(team2.members)  // [张三, 李四, 王五]
}

┌──────────────────────────────────────────────────────────────┐
│                    浅拷贝内存示意图                            │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│   team1 ──────► Team(name="开发组", members=ref1)            │
│                                          │                   │
│                                          ▼                   │
│                                   ┌─────────────┐            │
│                                   │ MutableList │            │
│                                   │ [张三,李四] │◄──┐        │
│                                   └─────────────┘   │        │
│                                          ▲          │        │
│                                          │          │        │
│   team2 ──────► Team(name="测试组", members=ref1)   │        │
│                                                     │        │
│                 两个对象的 members 指向同一个列表！    │        │
│                 (Both point to the same list!)──────┘        │
└──────────────────────────────────────────────────────────────┘

data class Product(
    val id: String,
    val name: String,
    val price: Double
)
 
fun main() {
    val p1 = Product("A001", "键盘", 299.0)
    val p2 = Product("A001", "键盘", 299.0)
    val p3 = Product("A001", "键盘", 399.0)  // 价格不同
    
    // equals：比较所有主构造函数属性
    println(p1 == p2)   // true  (所有属性相同)
    println(p1 == p3)   // false (price 不同)
    println(p1 === p2)  // false (不是同一个对象实例)
    
    // hashCode：相等的对象必须有相同的哈希码
    println(p1.hashCode() == p2.hashCode())  // true
    
    // 可以安全地用作 Map 的 key 或放入 Set
    val productSet = setOf(p1, p2, p3)
    println(productSet.size)  // 2 (p1 和 p2 被视为相同)
}

// equals 的生成逻辑（伪代码）
override fun equals(other: Any?): Boolean {
    // 1. 引用相等检查（快速路径）
    if (this === other) return true
    
    // 2. 类型检查
    if (other !is Product) return false
    
    // 3. 逐个属性比较（主构造函数中的所有属性）
    if (id != other.id) return false
    if (name != other.name) return false
    if (price != other.price) return false
    
    return true
}
 
// hashCode 的生成逻辑（伪代码）
override fun hashCode(): Int {
    // 使用所有属性计算哈希码
    var result = id.hashCode()
    result = 31 * result + name.hashCode()
    result = 31 * result + price.hashCode()
    return result
}

data class Article(
    val id: Long,           // ✓ 参与 equals/hashCode
    val title: String       // ✓ 参与 equals/hashCode
) {
    var viewCount: Int = 0  // ✗ 不参与！在类体中定义
    val summary: String     // ✗ 不参与！在类体中定义
        get() = title.take(20)
}
 
fun main() {
    val a1 = Article(1, "Kotlin 入门")
    val a2 = Article(1, "Kotlin 入门")
    
    a1.viewCount = 100
    a2.viewCount = 200
    
    // viewCount 不同，但 equals 仍然返回 true！
    println(a1 == a2)  // true
    println(a1.viewCount)  // 100
    println(a2.viewCount)  // 200
}

data class Config(val debug: Boolean, val version: Int) {
    var timestamp: Long = System.currentTimeMillis()
}
 
fun main() {
    val c1 = Config(true, 1)
    Thread.sleep(100)
    val c2 = Config(true, 1)
    println(c1 == c2)
}

data class User(
    val name: String,
    val age: Int,
    val email: String
)
 
fun main() {
    val user = User("张三", 28, "zhangsan@example.com")
    
    // 解构声明：一行代码创建三个变量
    // Destructuring declaration: create three variables in one line
    val (name, age, email) = user
    
    // 等价于以下三行代码：
    // val name = user.component1()
    // val age = user.component2()
    // val email = user.component3()
    
    println("姓名: $name")   // 姓名: 张三
    println("年龄: $age")    // 年龄: 28
    println("邮箱: $email")  // 邮箱: zhangsan@example.com
}

// 函数返回多个值的场景
// Function returning multiple values
fun getMinMax(numbers: List<Int>): Pair<Int, Int> {
    return Pair(numbers.minOrNull() ?: 0, numbers.maxOrNull() ?: 0)
}
 
fun getStatistics(numbers: List<Int>): Triple<Int, Int, Double> {
    val min = numbers.minOrNull() ?: 0
    val max = numbers.maxOrNull() ?: 0
    val avg = numbers.average()
    return Triple(min, max, avg)
}
 
fun main() {
    val numbers = listOf(3, 1, 4, 1, 5, 9, 2, 6)
    
    // 解构 Pair
    val (min, max) = getMinMax(numbers)
    println("最小值: $min, 最大值: $max")  // 最小值: 1, 最大值: 9
    
    // 解构 Triple
    val (minimum, maximum, average) = getStatistics(numbers)
    println("最小: $minimum, 最大: $maximum, 平均: $average")
}

fun main() {
    val scores = mapOf("张三" to 95, "李四" to 87, "王五" to 92)
    
    // 直接在赋值中解构 Map.Entry
    val firstEntry = scores.entries.first()
    val (name, score) = firstEntry
    
    println("$name 的分数是 $score")  // 张三 的分数是 95
}

data class Student(
    val id: Int,
    val name: String,
    val grade: Double
)
 
fun main() {
    val students = listOf(
        Student(1, "张三", 89.5),
        Student(2, "李四", 92.0),
        Student(3, "王五", 78.5)
    )
    
    // 在 for 循环中解构每个 Student 对象
    // Destructuring in for loop
    for ((id, name, grade) in students) {
        println("学号: $id, 姓名: $name, 成绩: $grade")
    }
    // 输出:
    // 学号: 1, 姓名: 张三, 成绩: 89.5
    // 学号: 2, 姓名: 李四, 成绩: 92.0
    // 学号: 3, 姓名: 王五, 成绩: 78.5
}

fun main() {
    val capitals = mapOf(
        "中国" to "北京",
        "日本" to "东京",
        "韩国" to "首尔",
        "美国" to "华盛顿"
    )
    
    // 传统写法（不使用解构）
    for (entry in capitals) {
        println("${entry.key} 的首都是 ${entry.value}")
    }
    
    // 使用解构的简洁写法
    // Destructuring makes iteration cleaner
    for ((country, capital) in capitals) {
        println("$country 的首都是 $capital")
    }
}

fun main() {
    val fruits = listOf("苹果", "香蕉", "橙子", "葡萄")
    
    // withIndex() 返回 IndexedValue<T>，可以解构为 (index, value)
    for ((index, fruit) in fruits.withIndex()) {
        println("第 ${index + 1} 个水果: $fruit")
    }
    // 输出:
    // 第 1 个水果: 苹果
    // 第 2 个水果: 香蕉
    // 第 3 个水果: 橙子
    // 第 4 个水果: 葡萄
}

fun main() {
    val users = mapOf(
        1 to "张三",
        2 to "李四",
        3 to "王五"
    )
    
    // 传统写法：Lambda 参数是 Map.Entry
    users.forEach { entry ->
        println("ID: ${entry.key}, 姓名: ${entry.value}")
    }
    
    // 解构写法：直接在 Lambda 参数位置解构
    // Destructuring in lambda parameters
    users.forEach { (id, name) ->
        println("ID: $id, 姓名: $name")
    }
}

data class Product(
    val name: String,
    val price: Double,
    val stock: Int
)
 
fun main() {
    val products = listOf(
        Product("键盘", 299.0, 50),
        Product("鼠标", 99.0, 100),
        Product("显示器", 1999.0, 20)
    )
    
    // 使用解构让 filter 条件更清晰
    val expensiveProducts = products.filter { (_, price, _) ->
        price > 200  // 只关心价格，其他用下划线忽略
    }
    
    // 使用解构让 map 转换更直观
    val productInfo = products.map { (name, price, stock) ->
        "$name: ¥$price (库存: $stock)"
    }
    
    productInfo.forEach { println(it) }
    // 输出:
    // 键盘: ¥299.0 (库存: 50)
    // 鼠标: ¥99.0 (库存: 100)
    // 显示器: ¥1999.0 (库存: 20)
}

fun main() {
    val pairs = listOf(1 to "一", 2 to "二", 3 to "三")
    
    // ✗ 错误：解构参数必须用括号包裹
    // pairs.forEach { a, b -> println("$a = $b") }
    
    // ✓ 正确：解构参数需要括号
    pairs.forEach { (a, b) -> println("$a = $b") }
    
    // 如果 Lambda 只有一个参数且不解构，可以用 it
    pairs.forEach { println("${it.first} = ${it.second}") }
}

data class Employee(
    val id: Int,
    val name: String,
    val department: String,
    val salary: Double
)
 
fun main() {
    val employee = Employee(1001, "张三", "技术部", 15000.0)
    
    // 只需要姓名和薪资，忽略 id 和 department
    // Use underscore to ignore unwanted components
    val (_, name, _, salary) = employee
    
    println("$name 的薪资是 ¥$salary")  // 张三 的薪资是 ¥15000.0
    
    // 在循环中忽略不需要的部分
    val employees = listOf(
        Employee(1001, "张三", "技术部", 15000.0),
        Employee(1002, "李四", "市场部", 12000.0)
    )
    
    // 只关心姓名和部门
    for ((_, name, dept, _) in employees) {
        println("$name 在 $dept 工作")
    }
}

fun main() {
    val config = mapOf(
        "host" to "localhost",
        "port" to "8080",
        "timeout" to "30"
    )
    
    // 只需要值，忽略键
    println("配置值列表:")
    for ((_, value) in config) {
        println("  - $value")
    }
    
    // 只需要键，忽略值
    println("配置项列表:")
    for ((key, _) in config) {
        println("  - $key")
    }
}

// 多个下划线是独立的，不会冲突
// Multiple underscores are independent
val (_, _, third, _) = listOf(1, 2, 3, 4).let { 
    object {
        operator fun component1() = it[0]
        operator fun component2() = it[1]
        operator fun component3() = it[2]
        operator fun component4() = it[3]
    }
}
println(third)  // 3

┌────────────────────────────────────────────────────────────┐
│                    解构声明使用场景总结                       │
├────────────────────────────────────────────────────────────┤
│                                                            │
│  赋值中:    val (a, b, c) = dataObject                     │
│                                                            │
│  循环中:    for ((key, value) in map) { ... }             │
│                                                            │
│  Lambda中:  map.forEach { (k, v) -> ... }                 │
│                                                            │
│  忽略组件:  val (_, name, _) = triple                      │
│                                                            │
│  ⚠️ 注意: 解构顺序由 componentN() 决定，与变量名无关！        │
│                                                            │
└────────────────────────────────────────────────────────────┘

data class Point(val x: Int, val y: Int)
 
fun main() {
    val points = listOf(Point(1, 2), Point(3, 4))
    for ((y, x) in points) {
        print("($x,$y) ")
    }
}

// 定义一个密封类表示网络请求结果
// Sealed class representing network request result
sealed class NetworkResult<out T> {
    // 成功：携带数据
    data class Success<T>(val data: T) : NetworkResult<T>()
    
    // 失败：携带错误信息
    data class Error(val message: String, val code: Int) : NetworkResult<Nothing>()
    
    // 加载中：无额外数据
    data object Loading : NetworkResult<Nothing>()
}
 
fun <T> handleResult(result: NetworkResult<T>): String {
    // when 表达式可以穷尽所有可能，无需 else 分支
    return when (result) {
        is NetworkResult.Success -> "成功: ${result.data}"
        is NetworkResult.Error -> "错误 ${result.code}: ${result.message}"
        is NetworkResult.Loading -> "加载中..."
    }
}

// 密封类本身是抽象的，不能直接实例化
// Sealed classes are implicitly abstract
sealed class Shape {
    // 可以有抽象成员
    abstract fun area(): Double
    
    // 也可以有具体成员
    fun describe(): String = "这是一个 ${this::class.simpleName}"
}
 
// 子类可以是 data class
data class Circle(val radius: Double) : Shape() {
    override fun area() = Math.PI * radius * radius
}
 
// 子类可以是普通 class
class Rectangle(val width: Double, val height: Double) : Shape() {
    override fun area() = width * height
}
 
// 子类可以是 object（单例）
data object Unknown : Shape() {
    override fun area() = 0.0
}

// 文件: Result.kt
package com.example.result
 
// 密封类定义
sealed class Result<out T>
 
// 直接子类可以在同一文件中
data class Success<T>(val value: T) : Result<T>()
data class Failure(val error: Throwable) : Result<Nothing>()

// 文件: ResultExtensions.kt (同一包中的另一个文件)
package com.example.result
 
// Kotlin 1.5+ 允许在同一包的不同文件中定义子类
data object Pending : Result<Nothing>()
 
// 但是！其他模块或其他包中无法继承 Result
// ✗ 以下代码在其他包中会编译失败
// class CustomResult : Result<String>()  // Error!

// 假设 Result 不是密封类，而是普通的 open class
open class OpenResult<out T>
class Success<T>(val value: T) : OpenResult<T>()
class Failure(val error: Throwable) : OpenResult<Nothing>()
 
fun handleOpen(result: OpenResult<String>): String {
    return when (result) {
        is Success -> result.value
        is Failure -> result.error.message ?: "Unknown error"
        else -> "未知类型"  // 必须有 else！因为可能有其他子类
    }
}
 
// 问题：任何人都可以在任何地方添加新的子类
class HackedResult : OpenResult<String>()  // 完全合法！
 
// 这会导致 handleOpen 函数的 else 分支被触发
// 而开发者可能完全没有预料到这种情况

sealed class PaymentMethod {
    data class CreditCard(val number: String, val cvv: String) : PaymentMethod()
    data class DebitCard(val number: String, val pin: String) : PaymentMethod()
    data class Cash(val amount: Double) : PaymentMethod()
    data object WeChatPay : PaymentMethod()
    data object Alipay : PaymentMethod()
}
 
fun processPayment(method: PaymentMethod): String {
    // 编译器知道所有可能的子类，强制处理每一种
    // Compiler knows all possible subclasses, enforces handling each
    return when (method) {
        is PaymentMethod.CreditCard -> "信用卡支付: ${method.number}"
        is PaymentMethod.DebitCard -> "借记卡支付: ${method.number}"
        is PaymentMethod.Cash -> "现金支付: ¥${method.amount}"
        PaymentMethod.WeChatPay -> "微信支付"
        PaymentMethod.Alipay -> "支付宝支付"
        // 无需 else 分支！所有情况都已覆盖
    }
}

// 假设后来添加了新的支付方式
sealed class PaymentMethod {
    // ... 原有子类 ...
    data object ApplePay : PaymentMethod()  // 新增！
}
 
// 此时 processPayment 函数会编译失败！
// Compilation error: 'when' expression must be exhaustive
// 错误信息会明确指出缺少 ApplePay 分支
 
// 这就是穷尽性保证的价值：
// 编译器强制你处理所有情况，不会遗漏任何分支

sealed class State {
    data object Idle : State()
    data object Loading : State()
    data class Success(val data: String) : State()
    data class Error(val message: String) : State()
}
 
fun demo(state: State) {
    // when 作为表达式（有返回值）：必须穷尽
    val message: String = when (state) {
        State.Idle -> "空闲"
        State.Loading -> "加载中"
        is State.Success -> "成功: ${state.data}"
        is State.Error -> "错误: ${state.message}"
    }
    
    // when 作为语句（无返回值）：不强制穷尽，但建议穷尽
    when (state) {
        State.Idle -> println("空闲状态")
        State.Loading -> println("正在加载...")
        // 即使不处理 Success 和 Error 也能编译通过
        // 但这通常不是好的实践
        else -> { }  // 或者用 else 兜底
    }
}

sealed class UIEvent {
    sealed class Click : UIEvent() {
        data class Button(val id: String) : Click()
        data class Link(val url: String) : Click()
    }
    
    sealed class Input : UIEvent() {
        data class Text(val content: String) : Input()
        data class Number(val value: Int) : Input()
    }
    
    data object Scroll : UIEvent()
}
 
fun handleEvent(event: UIEvent): String {
    return when (event) {
        // 可以直接匹配叶子类型
        is UIEvent.Click.Button -> "点击按钮: ${event.id}"
        is UIEvent.Click.Link -> "点击链接: ${event.url}"
        is UIEvent.Input.Text -> "输入文本: ${event.content}"
        is UIEvent.Input.Number -> "输入数字: ${event.value}"
        UIEvent.Scroll -> "滚动事件"
        // 所有叶子节点都被覆盖，无需 else
    }
}
 
// 也可以按中间层级匹配
fun handleEventSimple(event: UIEvent): String {
    return when (event) {
        is UIEvent.Click -> "点击事件"    // 匹配所有 Click 子类
        is UIEvent.Input -> "输入事件"    // 匹配所有 Input 子类
        UIEvent.Scroll -> "滚动事件"
    }
}

// 使用密封类建模有限状态机
// Modeling finite state machine with sealed class
sealed class OrderState {
    // 初始状态：待支付
    data object Pending : OrderState()
    
    // 已支付，等待发货
    data class Paid(val paymentId: String) : OrderState()
    
    // 已发货
    data class Shipped(val trackingNumber: String) : OrderState()
    
    // 已送达
    data class Delivered(val signedBy: String) : OrderState()
    
    // 已取消
    data class Cancelled(val reason: String) : OrderState()
}
 
// 状态转换函数：编译器确保处理所有状态
fun getNextActions(state: OrderState): List<String> {
    return when (state) {
        OrderState.Pending -> listOf("支付", "取消订单")
        is OrderState.Paid -> listOf("发货", "退款")
        is OrderState.Shipped -> listOf("确认收货", "申请退货")
        is OrderState.Delivered -> listOf("评价", "申请售后")
        is OrderState.Cancelled -> listOf("重新下单")
    }
}

┌─────────────────────────────────────────────────────────────────┐
│                    密封类核心价值总结                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  1. 类型安全 (Type Safety)                                      │
│     └─ 编译时已知所有子类，无法在外部扩展                          │
│                                                                 │
│  2. 穷尽性检查 (Exhaustiveness)                                 │
│     └─ when 表达式必须处理所有分支，遗漏会编译失败                  │
│                                                                 │
│  3. 重构安全 (Refactoring Safety)                               │
│     └─ 新增子类时，所有未处理的 when 都会报错                      │
│                                                                 │
│  4. 代替枚举 (Enum Alternative)                                 │
│     └─ 比枚举更灵活：每个子类可以有不同的属性和行为                  │
│                                                                 │
│  适用场景: 状态机、结果类型、事件系统、AST 节点、协议消息           │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

sealed class Animal {
    data class Dog(val name: String) : Animal()
    data class Cat(val name: String) : Animal()
}
 
fun describe(animal: Animal): String = when (animal) {
    is Animal.Dog -> "狗: ${animal.name}"
}

// 定义一个密封接口，表示所有可序列化的事件
// A sealed interface representing all serializable events
sealed interface Event {
    val timestamp: Long  // 接口可以声明抽象属性
}
 
// 直接实现者必须在同一编译单元（同一模块）内定义
data class ClickEvent(
    override val timestamp: Long,
    val x: Int,
    val y: Int
) : Event
 
data class KeyEvent(
    override val timestamp: Long,
    val keyCode: Int
) : Event
 
data class ScrollEvent(
    override val timestamp: Long,
    val delta: Int
) : Event
 
// 处理事件时，编译器确保所有类型都被处理
fun logEvent(event: Event): String = when (event) {
    is ClickEvent -> "点击事件: (${event.x}, ${event.y})"
    is KeyEvent -> "按键事件: keyCode=${event.keyCode}"
    is ScrollEvent -> "滚动事件: delta=${event.delta}"
    // 无需 else 分支，编译器知道所有可能的实现
}

// 定义多个正交的密封接口，表示不同的能力维度
// Multiple orthogonal sealed interfaces for different capability dimensions
 
// 可持久化的（能保存到数据库）
sealed interface Persistable {
    val id: String
    fun toJson(): String
}
 
// 可验证的（能进行数据校验）
sealed interface Validatable {
    fun validate(): Boolean
}
 
// 可审计的（能记录操作日志）
sealed interface Auditable {
    val createdAt: Long
    val modifiedAt: Long
}
 
// 一个类可以同时实现多个密封接口！
// A class can implement multiple sealed interfaces simultaneously!
data class UserProfile(
    override val id: String,
    override val createdAt: Long,
    override val modifiedAt: Long,
    val name: String,
    val email: String
) : Persistable, Validatable, Auditable {
    
    override fun toJson(): String = 
        """{"id":"$id","name":"$name","email":"$email"}"""
    
    override fun validate(): Boolean = 
        name.isNotBlank() && email.contains("@")
}
 
// 订单数据：可持久化 + 可验证，但不需要审计
data class OrderData(
    override val id: String,
    val items: List<String>,
    val total: Double
) : Persistable, Validatable {
    
    override fun toJson(): String = 
        """{"id":"$id","total":$total}"""
    
    override fun validate(): Boolean = 
        items.isNotEmpty() && total > 0
}

// 如果用密封类，就无法组合多个维度
sealed class Persistable      // 类 A
sealed class Validatable      // 类 B
 
// ❌ 编译错误：一个类不能继承多个类
// class UserProfile : Persistable(), Validatable()

// 顶层使用密封接口，定义最抽象的分类
// Top level: sealed interface for the most abstract categorization
sealed interface UIComponent {
    val id: String
    fun render(): String
}
 
// 中间层使用密封类，为某一类组件提供公共实现
// Middle level: sealed class for shared implementation
sealed class InputComponent(
    override val id: String,
    val label: String
) : UIComponent {
    // 公共属性和方法
    val isRequired: Boolean = false
}
 
// 叶子节点：具体的输入组件
data class TextField(
    override val id: String,
    val placeholder: String,
    private val labelText: String
) : InputComponent(id, labelText) {
    override fun render() = "<input type='text' placeholder='$placeholder'/>"
}
 
data class Checkbox(
    override val id: String,
    val checked: Boolean,
    private val labelText: String
) : InputComponent(id, labelText) {
    override fun render() = "<input type='checkbox' checked='$checked'/>"
}
 
// 另一个分支：展示组件（直接实现接口）
data class Label(
    override val id: String,
    val text: String
) : UIComponent {
    override fun render() = "<span>$text</span>"
}
 
data class Image(
    override val id: String,
    val src: String,
    val alt: String
) : UIComponent {
    override fun render() = "<img src='$src' alt='$alt'/>"
}

// 规则1：直接子类型必须在同一编译单元（模块）内
// Rule 1: Direct subtypes must be in the same compilation unit (module)
sealed interface Payment
 
// ✓ 同一模块内，可以实现
class CreditCardPayment : Payment
class WeChatPayment : Payment
 
// ✗ 其他模块无法直接实现 Payment 接口
 
// 规则2：可以有非密封的中间层
// Rule 2: Can have non-sealed intermediate layers
sealed interface Animal
 
// 非密封的中间接口
interface Mammal : Animal  // 普通接口继承密封接口
 
// 任何地方都可以实现 Mammal（因为 Mammal 不是密封的）
class Dog : Mammal
class Cat : Mammal
 
// 但是！when 表达式对 Animal 的穷尽性检查会失效
// Because Mammal is not sealed, exhaustiveness is lost for Animal
fun describe(animal: Animal): String = when (animal) {
    is Mammal -> "这是哺乳动物"
    else -> "未知动物"  // 必须有 else，因为 Mammal 不是密封的
}

// 场景：一个简单的算术表达式系统
// Scenario: A simple arithmetic expression system
 
// 使用密封类定义表达式的所有可能形式
sealed class Expr {
    data class Num(val value: Double) : Expr()           // 数字字面量
    data class Add(val left: Expr, val right: Expr) : Expr()  // 加法
    data class Mul(val left: Expr, val right: Expr) : Expr()  // 乘法
}
 
// 操作1：求值
fun Expr.eval(): Double = when (this) {
    is Expr.Num -> value
    is Expr.Add -> left.eval() + right.eval()
    is Expr.Mul -> left.eval() * right.eval()
}
 
// 操作2：转为字符串
fun Expr.show(): String = when (this) {
    is Expr.Num -> value.toString()
    is Expr.Add -> "(${left.show()} + ${right.show()})"
    is Expr.Mul -> "(${left.show()} * ${right.show()})"
}
 
fun main() {
    // 构建表达式: (1 + 2) * 3
    val expr = Expr.Mul(
        Expr.Add(Expr.Num(1.0), Expr.Num(2.0)),
        Expr.Num(3.0)
    )
    
    println(expr.show())  // ((1.0 + 2.0) * 3.0)
    println(expr.eval())  // 9.0
}

// 假设我们要添加新的表达式类型：减法
sealed class Expr {
    data class Num(val value: Double) : Expr()
    data class Add(val left: Expr, val right: Expr) : Expr()
    data class Mul(val left: Expr, val right: Expr) : Expr()
    data class Sub(val left: Expr, val right: Expr) : Expr()  // 新增！
}
 
// 编译器会立即报错，提示 eval() 和 show() 中的 when 不完整
// Compiler immediately errors: when is not exhaustive
fun Expr.eval(): Double = when (this) {
    is Expr.Num -> value
    is Expr.Add -> left.eval() + right.eval()
    is Expr.Mul -> left.eval() * right.eval()
    // ❌ 编译错误：'when' expression must be exhaustive, 
    //    add necessary 'is Sub' branch or 'else' branch
    is Expr.Sub -> left.eval() - right.eval()  // 必须添加这行
}

// 使用密封类精确建模 JSON 的所有可能值类型
// Model all possible JSON value types with sealed class
sealed class JsonValue {
    // JSON 对象：键值对的集合
    data class JsonObject(val members: Map<String, JsonValue>) : JsonValue()
    
    // JSON 数组：值的有序列表
    data class JsonArray(val elements: List<JsonValue>) : JsonValue()
    
    // JSON 字符串
    data class JsonString(val value: String) : JsonValue()
    
    // JSON 数字
    data class JsonNumber(val value: Double) : JsonValue()
    
    // JSON 布尔值
    data class JsonBoolean(val value: Boolean) : JsonValue()
    
    // JSON null
    data object JsonNull : JsonValue()
}
 
// 类型安全的 JSON 操作：获取嵌套值
// Type-safe JSON operation: get nested value
fun JsonValue.getPath(vararg keys: String): JsonValue? {
    var current: JsonValue = this
    
    for (key in keys) {
        current = when (current) {
            is JsonValue.JsonObject -> current.members[key] ?: return null
            is JsonValue.JsonArray -> {
                val index = key.toIntOrNull() ?: return null
                current.elements.getOrNull(index) ?: return null
            }
            // 其他类型无法继续深入
            is JsonValue.JsonString,
            is JsonValue.JsonNumber,
            is JsonValue.JsonBoolean,
            JsonValue.JsonNull -> return null
        }
    }
    return current
}
 
// 类型安全的转换：尝试获取字符串值
fun JsonValue.asString(): String? = when (this) {
    is JsonValue.JsonString -> value
    else -> null
}
 
// 类型安全的转换：尝试获取数字值
fun JsonValue.asNumber(): Double? = when (this) {
    is JsonValue.JsonNumber -> value
    else -> null
}
 
fun main() {
    // 构建 JSON: {"user": {"name": "张三", "age": 25}}
    val json = JsonValue.JsonObject(mapOf(
        "user" to JsonValue.JsonObject(mapOf(
            "name" to JsonValue.JsonString("张三"),
            "age" to JsonValue.JsonNumber(25.0)
        ))
    ))
    
    // 类型安全地访问嵌套值
    val name = json.getPath("user", "name")?.asString()
    val age = json.getPath("user", "age")?.asNumber()
    
    println("姓名: $name")  // 姓名: 张三
    println("年龄: $age")   // 年龄: 25.0
}

// 文件系统的类型安全表示
// Type-safe representation of a file system
sealed class FileSystemNode {
    abstract val name: String
    
    // 文件：叶子节点
    data class File(
        override val name: String,
        val size: Long,
        val extension: String
    ) : FileSystemNode()
    
    // 目录：可以包含子节点
    data class Directory(
        override val name: String,
        val children: List<FileSystemNode>
    ) : FileSystemNode()
    
    // 符号链接：指向另一个节点
    data class SymLink(
        override val name: String,
        val target: String
    ) : FileSystemNode()
}
 
// 递归计算总大小
// Recursively calculate total size
fun FileSystemNode.totalSize(): Long = when (this) {
    is FileSystemNode.File -> size
    is FileSystemNode.Directory -> children.sumOf { it.totalSize() }
    is FileSystemNode.SymLink -> 0L  // 符号链接本身不占空间
}
 
// 递归查找所有文件
// Recursively find all files
fun FileSystemNode.findAllFiles(): List<FileSystemNode.File> = when (this) {
    is FileSystemNode.File -> listOf(this)
    is FileSystemNode.Directory -> children.flatMap { it.findAllFiles() }
    is FileSystemNode.SymLink -> emptyList()
}
 
// 格式化打印树结构
// Pretty print tree structure
fun FileSystemNode.printTree(indent: String = ""): String = when (this) {
    is FileSystemNode.File -> 
        "$indent📄 $name ($size bytes)\n"
    is FileSystemNode.Directory -> 
        "$indent📁 $name/\n" + children.joinToString("") { 
            it.printTree("$indent  ") 
        }
    is FileSystemNode.SymLink -> 
        "$indent🔗 $name -> $target\n"
}
 
fun main() {
    // 构建文件系统树
    val root = FileSystemNode.Directory("project", listOf(
        FileSystemNode.File("README.md", 1024, "md"),
        FileSystemNode.Directory("src", listOf(
            FileSystemNode.File("Main.kt", 2048, "kt"),
            FileSystemNode.File("Utils.kt", 512, "kt")
        )),
        FileSystemNode.SymLink("latest", "src/Main.kt")
    ))
    
    println(root.printTree())
    println("总大小: ${root.totalSize()} bytes")
    println("文件数: ${root.findAllFiles().size}")
}

// 订单状态机：类型安全地建模所有可能的状态和转换
// Order state machine: type-safe modeling of all states and transitions
sealed class OrderState {
    // 待支付状态
    data class Pending(
        val orderId: String,
        val amount: Double,
        val createdAt: Long
    ) : OrderState()
    
    // 已支付状态
    data class Paid(
        val orderId: String,
        val amount: Double,
        val paidAt: Long,
        val transactionId: String
    ) : OrderState()
    
    // 已发货状态
    data class Shipped(
        val orderId: String,
        val shippedAt: Long,
        val trackingNumber: String
    ) : OrderState()
    
    // 已完成状态
    data class Completed(
        val orderId: String,
        val completedAt: Long
    ) : OrderState()
    
    // 已取消状态
    data class Cancelled(
        val orderId: String,
        val cancelledAt: Long,
        val reason: String
    ) : OrderState()
}
 
// 状态转换函数：只有合法的转换才能编译通过
// State transition: only valid transitions compile
 
// 支付操作：只能从 Pending 转换到 Paid
fun OrderState.Pending.pay(transactionId: String): OrderState.Paid {
    return OrderState.Paid(
        orderId = orderId,
        amount = amount,
        paidAt = System.currentTimeMillis(),
        transactionId = transactionId
    )
}
 
// 发货操作：只能从 Paid 转换到 Shipped
fun OrderState.Paid.ship(trackingNumber: String): OrderState.Shipped {
    return OrderState.Shipped(
        orderId = orderId,
        shippedAt = System.currentTimeMillis(),
        trackingNumber = trackingNumber
    )
}
 
// 完成操作：只能从 Shipped 转换到 Completed
fun OrderState.Shipped.complete(): OrderState.Completed {
    return OrderState.Completed(
        orderId = orderId,
        completedAt = System.currentTimeMillis()
    )
}
 
// 取消操作：只能从 Pending 或 Paid 状态取消
fun OrderState.Pending.cancel(reason: String): OrderState.Cancelled {
    return OrderState.Cancelled(orderId, System.currentTimeMillis(), reason)
}
 
fun OrderState.Paid.cancel(reason: String): OrderState.Cancelled {
    return OrderState.Cancelled(orderId, System.currentTimeMillis(), reason)
}
 
// 获取状态描述
fun OrderState.describe(): String = when (this) {
    is OrderState.Pending -> "订单 $orderId 待支付，金额 ¥$amount"
    is OrderState.Paid -> "订单 $orderId 已支付，交易号 $transactionId"
    is OrderState.Shipped -> "订单 $orderId 已发货，运单号 $trackingNumber"
    is OrderState.Completed -> "订单 $orderId 已完成"
    is OrderState.Cancelled -> "订单 $orderId 已取消，原因: $reason"
}

fun main() {
    // 创建订单
    val order = OrderState.Pending("ORD-001", 99.9, System.currentTimeMillis())
    
    // ✓ 合法操作：待支付 -> 已支付
    val paidOrder = order.pay("TXN-12345")
    
    // ✓ 合法操作：已支付 -> 已发货
    val shippedOrder = paidOrder.ship("SF-98765")
    
    // ❌ 编译错误：已发货状态没有 cancel() 方法
    // shippedOrder.cancel("不想要了")  // 无法编译！
    
    // ❌ 编译错误：待支付状态没有 ship() 方法
    // order.ship("SF-00000")  // 无法编译！
    
    // 类型系统确保了状态转换的合法性
    // The type system ensures valid state transitions
}

sealed class State {
    object Loading : State()
    data class Success(val data: String) : State()
    data class Error(val message: String) : State()
}
 
fun State.Loading.retry(): State = State.Loading
fun State.Error.retry(): State = State.Loading

// 最简单的枚举定义：一周的七天
// Simplest enum: Days of the week
enum class DayOfWeek {
    MONDAY,      // 每个常量都是 DayOfWeek 类型的单例
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY       // 最后一个常量后面不需要逗号
}
 
fun main() {
    // 使用枚举常量
    val today: DayOfWeek = DayOfWeek.FRIDAY
    
    // 枚举常量是单例，可以用 === 比较引用
    val anotherFriday = DayOfWeek.FRIDAY
    println(today === anotherFriday)  // true，同一个实例
    
    // 在 when 表达式中使用（推荐用法）
    val message = when (today) {
        DayOfWeek.MONDAY -> "新的一周开始了"
        DayOfWeek.FRIDAY -> "周五啦！"
        DayOfWeek.SATURDAY, DayOfWeek.SUNDAY -> "周末愉快"
        else -> "工作日继续加油"
    }
    println(message)  // 周五啦！
}

// 枚举常量的命名约定 (Naming Convention)
enum class HttpStatus {
    OK,                    // ✓ 全大写，下划线分隔
    NOT_FOUND,             // ✓ 标准命名
    INTERNAL_SERVER_ERROR  // ✓ 清晰表达含义
}
 
// 避免的命名方式
enum class BadNaming {
    ok,           // ✗ 小写不符合约定
    NotFound,     // ✗ 驼峰命名不推荐
    error500      // ✗ 数字开头的含义不清
}

// 枚举常量可以通过主构造函数接收参数
// Enum constants can receive parameters via primary constructor
enum class Planet(
    val mass: Double,           // 质量（相对于地球）
    val radius: Double,         // 半径（相对于地球）
    val chineseName: String     // 中文名称
) {
    // 每个常量都必须传入构造函数参数
    MERCURY(0.055, 0.383, "水星"),
    VENUS(0.815, 0.949, "金星"),
    EARTH(1.0, 1.0, "地球"),
    MARS(0.107, 0.532, "火星"),
    JUPITER(317.8, 11.21, "木星"),
    SATURN(95.2, 9.45, "土星"),
    URANUS(14.5, 4.01, "天王星"),
    NEPTUNE(17.1, 3.88, "海王星");  // 注意：如果后面有成员，最后一个常量要加分号
    
    // 枚举类可以定义方法
    // Enum class can define methods
    fun surfaceGravity(): Double {
        // 表面重力 = 质量 / 半径²（简化公式）
        return mass / (radius * radius)
    }
    
    // 也可以定义计算属性
    val description: String
        get() = "$chineseName: 质量=${mass}地球, 半径=${radius}地球"
}
 
fun main() {
    val earth = Planet.EARTH
    println(earth.chineseName)        // 地球
    println(earth.surfaceGravity())   // 1.0
    
    // 遍历所有行星
    Planet.entries.forEach { planet ->
        println("${planet.chineseName} 的表面重力: %.2f".format(planet.surfaceGravity()))
    }
}

// 枚举常量可以覆盖抽象方法，实现多态行为
// Enum constants can override abstract methods for polymorphic behavior
enum class Operation {
    ADD {
        // 每个常量提供自己的实现
        override fun apply(a: Double, b: Double): Double = a + b
        override val symbol: String = "+"
    },
    SUBTRACT {
        override fun apply(a: Double, b: Double): Double = a - b
        override val symbol: String = "-"
    },
    MULTIPLY {
        override fun apply(a: Double, b: Double): Double = a * b
        override val symbol: String = "×"
    },
    DIVIDE {
        override fun apply(a: Double, b: Double): Double {
            require(b != 0.0) { "除数不能为零" }
            return a / b
        }
        override val symbol: String = "÷"
    };
    
    // 抽象方法：每个常量必须实现
    abstract fun apply(a: Double, b: Double): Double
    
    // 抽象属性：每个常量必须提供
    abstract val symbol: String
    
    // 普通方法：所有常量共享
    fun describe(a: Double, b: Double): String {
        return "$a $symbol $b = ${apply(a, b)}"
    }
}
 
fun main() {
    val op = Operation.ADD
    println(op.apply(10.0, 5.0))      // 15.0
    println(op.describe(10.0, 5.0))   // 10.0 + 5.0 = 15.0
    
    // 遍历所有操作
    Operation.entries.forEach { operation ->
        println(operation.describe(20.0, 4.0))
    }
    // 输出:
    // 20.0 + 4.0 = 24.0
    // 20.0 - 4.0 = 16.0
    // 20.0 × 4.0 = 80.0
    // 20.0 ÷ 4.0 = 5.0
}