密封类与密封接口（Sealed Classes and Sealed Interfaces in Depth）

本文档对标 MIT 6.005 Software Construction、Stanford CS193P iOS Development、CMU 15-214 Software Engineering 等海外名校课程的教学水准，系统讲解 Kotlin 密封类（sealed class）与密封接口（sealed interface）的设计动机、形式化语义、穷举检查（exhaustiveness checking）原理、代数数据类型（Algebraic Data Type, ADT）建模、递归结构与模式匹配、JVM 字节码实现以及企业级工程实践。本文不假设读者具备 Scala、Rust 或 Haskell 的前置经验，所有概念均从”为什么需要受限继承”出发，逐层深入到编译器实现层面。完成本文学习后，读者将能够运用密封类型构建类型安全的领域模型、状态机与递归数据结构，并理解其在现代架构（MVI、MVVM、Event Sourcing）中的核心作用。

目录

1. 学习目标
2. 历史动机与发展脉络
3. 形式化定义
4. 理论推导与原理解析
5. 代码示例
6. 对比分析
7. 常见陷阱与最佳实践
8. 工程实践
9. 案例研究
10. 习题
11. 参考文献
12. 延伸阅读

1. 学习目标

本章节遵循 Bloom 教育目标分类学（Bloom’s Taxonomy）的六个认知层级，由低阶到高阶逐层递进。Bloom 分类学由教育心理学家 Benjamin Bloom 于 1956 年提出，2001 年由 Anderson 与 Krathwohl 修订，是国际教育界普遍采用的认知能力分级框架。

1.1 Remember（记忆）

完成本章节后，学习者应能够准确记忆以下知识点：

• 复述 Kotlin 密封类（sealed class）的定义语法：sealed class ClassName，所有直接子类必须在同一文件（Kotlin 1.5 前要求）或同一包内（Kotlin 1.5+ 允许）声明。
• 列举密封类的三类合法子类形态：data class（携带数据）、object（单例）、普通 class（可继承）。
• 背诵密封接口（sealed interface）于 Kotlin 1.5 引入，允许类、其他密封接口、object 与 enum class 实现。
• 记忆 when 表达式穷举检查的触发条件：作为表达式使用（有返回值）且未提供 else 分支时，编译器强制要求覆盖所有子类型。
• 列举 Kotlin 1.0 至 2.0 期间密封类的关键演进：1.0 引入、1.1 支持子类在同文件不同位置、1.5 允许跨文件同包 + 引入密封接口、1.7 支持密封接口嵌套、1.9 与 K2 兼容、2.0 K2 全面优化穷举检查精度。
• 复述密封类构造器的可见性规则：默认 protected，可显式声明 private，但不能为 public 或 internal。
• 记忆密封类本身是抽象的（abstract），不能直接实例化，且不能声明为 open（隐式 abstract）。
• 列举密封类与枚举的四大差异：实例数量（多实例 vs 单实例）、状态携带（异构 vs 同构）、继承层级（可嵌套 vs 扁平）、类型参数（支持泛型 vs 不支持）。

1.2 Understand（理解）

• 用自己的语言解释”受限继承”（restricted inheritance）的含义：编译器在编译期就知道一个密封类的所有可能子类型，从而支持穷举检查。
• 阐述密封类如何解决”开放式继承 + when 分支”的类型安全问题：开放继承下编译器无法保证 when 覆盖所有子类，新增子类时旧代码可能遗漏分支；密封类在新增子类时强制所有 when 表达式更新或编译失败。
• 描述代数数据类型（Algebraic Data Type, ADT）的概念：由”和类型”（Sum Type）与”积类型”（Product Type）组合而成的数据类型，密封类对应和类型，data class 对应积类型。
• 解释为什么密封类在 JVM 字节码层面使用 @Metadata 注解而非特殊字节码：JVM 不原生支持密封类，Kotlin 编译器将子类列表序列化到 @Metadata 注解中，供编译器跨模块检查。
• 阐述密封接口相比密封类的两大优势：支持多继承（一个类可实现多个密封接口）与支持 enum class 实现（枚举值可作为密封接口的子类型）。
• 解释”穷举检查”（exhaustiveness checking）的实现原理：编译器收集密封类的所有直接子类（含嵌套），与 when 分支的 is 检查对比，缺失即报错。
• 描述智能转换（Smart Cast）在 when 分支中的作用：is Result.Success 后编译器自动将 result 细化为 Result.Success 类型，可直接访问 value 属性。
• 解释为什么密封类配合 out 型变（covariance）能优雅表达”成功有值、失败无值”的场景：Result<Nothing> 是 Result<T> 的子类型，可安全赋给 Result<T>。

1.3 Apply（应用）

• 在网络请求结果建模中使用 sealed class Result<out T>，覆盖 Loading、Success<T>、Error 三态，并在 UI 层用 when 穷举处理。
• 在 Android/iOS ViewModel 中使用密封类建模 UI 状态（Idle、Loading、Content、Error），配合 StateFlow 实现单向数据流。
• 使用嵌套密封类构建层级化的领域模型，如 sealed class UiState 嵌套 sealed class Content 与 sealed class Error，实现分层处理。
• 使用密封类建模递归数据结构（如表达式树、JSON 树、AST 节点），用 when 递归求值或遍历。
• 在 MVI 架构中使用密封类建模 Wish（用户意图）与 Effect（副作用），保证所有意图都有对应处理器。
• 在事件溯源（Event Sourcing）中使用密封类建模领域事件，所有事件类型在编译期已知。
• 使用 kotlinx.serialization 配合密封类，通过 @SerialName 类鉴别器实现多态 JSON 序列化。
• 在 KMP 项目中使用密封接口定义跨平台共享的领域模型，各平台实现各自的 UI 处理。

1.4 Analyze（分析）

• 反编译 Kotlin 密封类字节码，分析 @Metadata 注解中 d2 数组的存储结构：子类列表以 JVM 内部类名形式序列化。
• 对比密封类与 Scala sealed trait、Rust enum、Swift enum、Haskell data 的穷举检查机制：四者均支持编译期穷举，但实现机制不同（注解 vs 关键字 vs 编译器内置）。
• 分析嵌套密封类的穷举传播规则：when 处理外层密封类时，若分支只检查到 is Content（未深入子类），需要继续处理 Content 的子类，否则视为未穷举。
• 解构 Kotlin 1.5 跨文件子类的实现：编译器扫描同包所有 .kt 文件，收集直接子类，然后注入 @Metadata。
• 分析密封接口支持多继承的语义价值：一个 data class 可同时实现 Drawable 与 Clickable 两个密封接口，在两个独立的 when 中分别处理。
• 分析 Kotlin 2.0 K2 编译器对穷举检查的改进：K2 能识别更多边界条件（如 when 嵌套、is 后跟 !is、null 与非空分支组合），减少误报。
• 对比 when (x) { is A -> ...; is B -> ...; else -> ... }（带 else）与 when (x) { is A -> ...; is B -> ... }（无 else）在密封类场景下的语义差异：前者放弃穷举检查，新增子类不会报错；后者强制穷举，新增子类时编译失败。

1.5 Evaluate（评价）

• 评价 Kotlin 选择”包级受限继承”而非”模块级”或”文件级”的设计权衡：包级更灵活（支持多文件拆分），但跨模块时仍需 sealed 关键字显式声明子类位置。
• 评价密封类构造器默认 protected 的设计：相比 private 提供了子类可调用的便利，相比 public 限制了外部实例化，是合理的折中。
• 评估密封接口与密封类共存的设计：是否过度复杂？还是必要的灵活性补充？
• 评价 Kotlin 不引入 Rust match 的”绑定模式”（binding patterns）的决策：Kotlin 的 is + 智能转换已覆盖 80% 场景，但嵌套解构（如 Some(Some(x))）确实不如 Rust 优雅。
• 评估密封类在事件溯源架构中的适用性：相比 Java 的接口 + 实现类，密封类提供了编译期穷举保证，但牺牲了开放扩展性。
• 评价密封类配合 when 表达式 vs if-else 链：前者在编译期检查穷举，后者无任何保证，应优先选择 when。
• 评估 Kotlin 密封类与 Java record + sealed（Java 17+）的差异：Java 的 sealed 关键字与 permits 子句更显式，但语法更冗长；Kotlin 更简洁但依赖 @Metadata 注解。

1.6 Create（创造）

• 设计并实现一个完整的”表达式求值器”：用密封类建模算术表达式（常量、变量、加减乘除、函数调用），实现 eval(env: Map<String, Double>) 递归求值，并支持变量替换与简化。
• 设计一个基于密封类的”状态机 DSL”：定义 State、Event、Transition，用 when 穷举所有 state + event 组合，编译期保证完整性。
• 实现一个”JSON 树”建模与遍历框架：用密封类表示 JsonObject、JsonArray、JsonString、JsonNumber、JsonBoolean、JsonNull，实现 accept(visitor: JsonVisitor) 与 toString()。
• 撰写一份团队密封类使用规范：何时用密封类 vs 枚举、何时用密封接口、嵌套层级限制、when 表达式必须穷举（禁用 else）等。
• 设计一个跨平台 KMP 的”网络层”：用密封接口定义 ApiResult，共享模块返回 Flow<ApiResult<T>>，各平台 UI 层用 when 处理。
• 实现一个”领域事件溯源”框架：用密封类定义所有领域事件，提供 apply(event) 方法用 when 穷举更新聚合根状态。

2. 历史动机与发展脉络

2.1 问题背景：开放继承与类型安全的矛盾

面向对象语言的传统继承模型是”开放的”（open inheritance）：任何类都可以被任意子类继承（除非显式标记 final 或 sealed）。这种开放性带来了严重的类型安全问题，尤其在模式匹配场景下：

// 开放继承下的隐患
open class Shape
class Circle(val radius: Double) : Shape()
class Square(val side: Double) : Shape()

fun area(shape: Shape): Double = when (shape) {
    is Circle -> Math.PI * shape.radius * shape.radius
    is Square -> shape.side * shape.side
    // 问题：新增 Triangle 时，编译器不会提示这里需要更新
    else -> 0.0  // 兜底，掩盖了遗漏
}

开放继承的核心问题：

1. 编译器无法穷举：开放继承下，子类集合是开放的，编译器无法知道所有可能类型，无法强制 when 覆盖完整。
2. 遗忘性扩展：新增子类时，所有 when 处理代码都需要手动检查，遗漏即产生 bug。
3. else 分支的陷阱：为应对开放继承，开发者被迫添加 else 分支，但这会掩盖未来的遗漏。
4. 重构困难：删除一个子类时，所有相关 when 中的分支变为死代码，难以发现。

2.2 学术背景：代数数据类型与穷举检查

密封类的思想根植于函数式编程语言中的代数数据类型（ADT）理论：

• ML 语言（1973）：引入 datatype，如 datatype expr = Const of real | Sum of expr * expr | Mul of expr * expr，match 表达式强制穷举。
• Haskell（1990）：data Expr = Const Double | Sum Expr Expr | Mul Expr Expr | Neg Expr，case ... of ... 强制穷举，编译器在新增构造器时警告所有未更新的 case。
• OCaml（1996）：type expr = Const of float | Sum of expr * expr，模式匹配强制穷举。
• Scala（2004）：sealed trait Expr; case class Const(value: Double) extends Expr，sealed 关键字限制同文件继承，match 强制穷举。
• Rust（2010）：enum Expr { Const(f64), Sum(Box<Expr>, Box<Expr>), Mul(Box<Expr>, Box<Expr>), Neg(Box<Expr>) }，match 强制穷举，支持绑定模式。
• Swift（2014）：enum Expr { case Const(Double), Sum(Expr, Expr), Mul(Expr, Expr), Neg(Expr) }，switch 强制穷举。
• Java 17（2021）：引入 sealed class 与 permits 子句，switch 模式匹配支持穷举检查。

Kotlin 的设计选择：

• sealed 关键字：借鉴 Scala，简洁明确。
• when 表达式穷举：借鉴 Scala match、Haskell case。
• 不引入绑定模式：与 Scala/Rust 不同，Kotlin 用 is + 智能转换替代绑定模式，简洁性有余但表达力稍弱。
• data class 作为积类型：借鉴 Scala case class，自动生成 equals、hashCode、copy。

2.3 Kotlin 1.0（2016）：密封类初版

Kotlin 1.0 引入密封类，但限制严格：

// Kotlin 1.0
sealed class Expr {
    data class Const(val value: Double) : Expr()
    data class Sum(val left: Expr, val right: Expr) : Expr()
}

fun eval(e: Expr): Double = when (e) {
    is Expr.Const -> e.value
    is Expr.Sum -> eval(e.left) + eval(e.right)
    // 穷举检查：编译器知道只有 Const 与 Sum 两类
}

1.0 的限制：

1. 子类必须在同一文件中声明。
2. 子类必须直接嵌套在密封类内部（不能跨文件、不能跨包）。
3. 不支持密封接口（sealed interface）。
4. 穷举检查仅在 when 作为表达式使用时生效。

2.4 Kotlin 1.1（2017）：子类位置灵活化

Kotlin 1.1 放宽了子类位置限制：

// 同文件内，子类可在密封类外部声明
sealed class Shape

class Circle(val radius: Double) : Shape()
class Square(val side: Double) : Shape()

但仍要求：

1. 子类与密封类在同一文件。
2. 子类必须直接继承密封类（不能跨中间抽象层）。

2.5 Kotlin 1.5（2021）：跨文件与密封接口

Kotlin 1.5 是密封类型演进的里程碑：

1. 跨文件子类：允许密封类的子类在同一包内任意文件中声明，支持大型项目模块化拆分。

// 文件：shapes/Circle.kt
package com.example.shapes
class Circle(val radius: Double) : Shape()

// 文件：shapes/Square.kt
package com.example.shapes
class Square(val side: Double) : Shape()

// 文件：shapes/Shape.kt
package com.example.shapes
sealed class Shape

2. 密封接口（sealed interface）：引入密封接口，支持多继承与枚举实现。

sealed interface Drawable {
    fun draw()
}

sealed interface Clickable {
    fun onClick()
}

// 一个类可同时实现多个密封接口
data class Button(val label: String) : Drawable, Clickable {
    override fun draw() { /* ... */ }
    override fun onClick() { /* ... */ }
}

// 枚举也可实现密封接口
enum class Color : Drawable {
    RED, GREEN, BLUE;
    override fun draw() { /* ... */ }
}

3. 穷举检查改进：when 表达式穷举检查覆盖密封接口的所有实现类。

2.6 Kotlin 1.6-1.7（2021-2022）：细节优化

1.6-1.7 对密封类型进行了细节优化：

1. 密封接口嵌套：允许密封接口嵌套在密封类或密封接口内。
2. @SerialName 与密封类：kotlinx.serialization 改进对密封类的多态序列化支持。
3. 智能转换精度：K2 预览编译器改进了 is 检查后的智能转换。

2.7 Kotlin 1.9（2023）：K2 兼容

Kotlin 1.9 的 K2 编译器 Beta 版本对密封类型进行了兼容性测试：

1. 穷举检查精度：K2 能识别 when 嵌套、is + !is 组合等边界情况。
2. 错误信息改进：K2 提供更精确的穷举失败提示，列出缺失的子类。
3. 跨模块检查：K2 在跨模块使用密封类时也能正确检查穷举。

2.8 Kotlin 2.0（2024）：K2 全面成熟

Kotlin 2.0 的 K2 编译器对密封类型进行了全面优化：

1. 编译速度：K2 通过 FIR（Frontend Intermediate Representation）一次分析子类列表，避免 K1 的重复扫描。
2. 穷举检查智能化：K2 能识别 when 表达式中 null 分支、is 与对象单例的组合、嵌套密封类的传播。
3. 跨平台一致性：KMP 项目中 JVM、JS、Native 平台的穷举检查行为完全一致。
4. 更好的错误信息：K2 能精确指出缺失的子类名称，并支持 Quick Fix 自动生成 when 分支骨架。

2.9 与 Java 17 sealed 的对比

Java 17（2021 年 9 月）引入了 sealed 关键字与 permits 子句：

// Java 17
public sealed abstract class Shape permits Circle, Square, Triangle {
}

final class Circle extends Shape { /* ... */ }
final class Square extends Shape { /* ... */ }
final class Triangle extends Shape { /* ... */ }

Java 17 sealed 与 Kotlin sealed 的对比：

2.10 时间线总览

1973  ML — 引入 datatype，函数式 ADT 开端
1990  Haskell — data 声明，case 穷举
1996  OCaml — type 声明，match 穷举
2004  Scala — sealed trait，case class，match 穷举
2010  Rust — enum + match，支持绑定模式
2014  Swift — enum + switch 穷举
2016  Kotlin 1.0 — sealed class，when 穷举（同文件）
2017  Kotlin 1.1 — 子类可在同文件任意位置
2021  Kotlin 1.5 — 跨文件子类 + sealed interface
2021  Java 17 — sealed class + permits
2022  Kotlin 1.7 — 密封接口嵌套
2023  Kotlin 1.9 — K2 Beta，穷举检查精度提升
2024  Kotlin 2.0 — K2 GA，穷举检查智能化

3. 形式化定义

3.1 密封类的形式化定义

设 $\mathcal{T}$ 为 Kotlin 类型集合，$\mathcal{S} \subseteq \mathcal{T}$ 为密封类集合。密封类 $S \in \mathcal{S}$ 的形式化定义为一个三元组：

其中：

• $N$ 是密封类的名字（如 Result）。
• $\Sigma$ 是类型参数集合（如 $\{T\}$，可能为空）。
• $\mathcal{C} = \{C_1, C_2, \ldots, C_n\}$ 是密封类的所有直接子类（children）的有限集合，且 $|\mathcal{C}| \geq 1$。

关键约束：

1. 封闭性：$\mathcal{C}$ 是有限的且在编译期完全已知。
2. 不可实例化：$S$ 本身是抽象的，不能直接 S() 实例化。
3. 不可扩展：除 $\mathcal{C}$ 中的子类外，任何其他类不能继承 $S$。
4. 位置约束：所有 $C_i \in \mathcal{C}$ 必须与 $S$ 在同一包（Kotlin 1.5+）或同一文件（Kotlin 1.0-1.4）。

3.2 代数数据类型（ADT）视角

从代数数据类型视角，密封类对应”和类型”（Sum Type），data class 对应”积类型”（Product Type）。

和类型（Sum Type）：

表示 $S$ 的值”是 $C_1$ 或 $C_2$ 或 … 或 $C_n$ 中的一种”。

积类型（Product Type）：

表示 $C_i$ 的值”是 $T_{i,1}$ 与 $T_{i,2}$ 与 … 与 $T_{i,k_i}$ 的组合”。

示例：

sealed class Expr  // 和类型
data class Const(val value: Double) : Expr()  // 积类型：Double
data class Sum(val left: Expr, val right: Expr) : Expr()  // 积类型：Expr × Expr
data class Mul(val left: Expr, val right: Expr) : Expr()  // 积类型：Expr × Expr
object NegZero : Expr()  // 单位类型（Unit Type）

形式化：

这是递归定义的代数数据类型。

3.3 穷举检查的形式化

设 $S = (N, \Sigma, \mathcal{C})$ 是密封类，$W$ 是 when 表达式，$\mathcal{B}$ 是 $W$ 中的分支集合。每个分支 $b \in \mathcal{B}$ 通过 is 检查匹配若干子类。

穷举检查规则：

其中 $\text{Matches}(b)$ 是分支 $b$ 匹配的子类集合。

编译期错误：若 when 作为表达式（有返回值）且无 else 分支，而 $\bigcup_{b \in \mathcal{B}} \text{Matches}(b) \neq \mathcal{C}$，编译器报错：

error: when expression must be exhaustive. Add the missing branch or else branch.

嵌套密封类的穷举：

若 $C_i \in \mathcal{C}$ 本身是密封类 $C_i = (N_i, \Sigma_i, \mathcal{C}_i)$，则穷举检查要求：

即必须继续穷举 $C_i$ 的子类，或用 else 兜底。

3.4 子类型关系

密封类的子类型关系 $\sqsubseteq$：

且（若 $S$ 是泛型，带型变）：

示例：Result<Nothing> 是 Result<T> 的子类型（协变）：

sealed class Result<out T> {
    data class Success<T>(val value: T) : Result<T>()
    data class Error(val message: String) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

// Result<Nothing> 是 Result<Int> 的子类型
val r: Result<Int> = Result.Loading  // OK

3.5 when 表达式的形式化语义

when 表达式的形式化语义：

其中 $\text{matches}(b, x)$ 的定义取决于分支类型：

• is T ->：$\text{matches}(b, x) := x \text{ is } T$
• value ->：$\text{matches}(b, x) := x = \text{value}$
• else ->：$\text{matches}(b, x) := \text{true}$（总是匹配）

分支顺序：when 表达式按声明顺序匹配，第一个匹配的分支被执行。这意味着更具体的分支应放在更一般的分支之前。

3.6 密封接口的形式化定义

密封接口 $I$ 的形式化定义：

其中：

• $N$ 是接口名字。
• $\Sigma$ 是类型参数集合。
• $\mathcal{M}$ 是接口声明的抽象方法集合。
• $\mathcal{R}$ 是所有直接实现类（realizations）的有限集合，且 $|\mathcal{R}| \geq 1$。

关键约束：

1. $\mathcal{R}$ 中的元素可以是 class、data class、object、enum class 或其他密封接口。
2. 一个类可同时属于多个密封接口的 $\mathcal{R}$ 集合（多继承）。
3. 所有 $r \in \mathcal{R}$ 必须实现 $\mathcal{M}$ 中的所有抽象方法（除非 $r$ 本身是抽象的）。

3.7 智能转换的形式化

在 when 分支 is T -> 内，编译器对变量 $x$ 进行类型细化（type narrowing）：

即在 is T 成立的分支内，$x$ 的类型从 $S$ 细化为 $T$。

多重细化：在嵌套 when 或 is + 条件组合时，编译器维护累加的类型细化信息：

val result: Result<Int> = ...
when (result) {
    is Result.Success -> {
        // result: Result.Success<Int>
        if (result.value > 0) {
            // result.value: Int 且 > 0
        }
    }
}

3.8 JVM 字节码层面的表示

在 JVM 字节码层面，密封类是普通的抽象类，但携带 @Metadata 注解：

@Metadata(
    kotlin.KotlinMetadata(...),
    // d2 数组包含子类列表
    d2 = {"Lcom/example/Result;", "Success", "Error", "Loading", ...}
)
public abstract class Result {
    // 抽象类，无特殊字节码
}

@Metadata 注解的 d2 数组以字符串形式存储子类的 JVM 内部类名，供 Kotlin 编译器跨模块检查穷举。

Java 调用者视角：Java 代码将密封类视为普通抽象类，可继承（但不会触发穷举检查）：

// Java 代码可以继承 Kotlin 密封类（不推荐）
public class JavaResult extends Result { /* ... */ }

Kotlin 编译器会发出警告：This class inherits from a sealed class, but no corresponding @Metadata sub-class declaration is found.

3.9 密封类的型变

密封类支持泛型与型变（variance）：

sealed class Result<out T> {  // 协变
    data class Success<T>(val value: T) : Result<T>()
    data class Error(val message: String) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

形式化：

协变规则保证：

这使得 Loading 与 Error（无值分支）可统一赋给任意 Result<T>。

3.10 递归密封类的形式化

递归密封类（如表达式树）的形式化：

其中 $E$ 是密封类 Expr，$C, S, M, N$ 是其子类。这是递归方程，定义了无限深度的树结构。

Catamorphism（折叠）：递归 when 求值是 catamorphism 的实例：

4. 理论推导与原理解析

4.1 密封类如何解决开放继承问题

问题：开放继承下，when 无法穷举，新增子类不报错。

解决：密封类在编译期固定子类集合 $\mathcal{C}$，编译器比对 $\mathcal{C}$ 与 when 分支：

sealed class Shape
class Circle(val radius: Double) : Shape()
class Square(val side: Double) : Shape()

fun area(s: Shape): Double = when (s) {
    is Circle -> Math.PI * s.radius * s.radius
    is Square -> s.side * s.side
    // 编译器知道 C = {Circle, Square}，分支已穷举，无需 else
}

新增 Triangle 时：

class Triangle(val base: Double, val height: Double) : Shape()
// 此时 C = {Circle, Square, Triangle}

fun area(s: Shape): Double = when (s) {
    is Circle -> Math.PI * s.radius * s.radius
    is Square -> s.side * s.side
    // 编译错误：when 表达式必须穷举，缺少 Triangle 分支
}

编译器强制开发者更新 area，避免遗漏。

4.2 穷举检查的实现机制

Kotlin 1.x（K1 编译器）：

1. 子类收集：编译器扫描密封类所在包的所有 .kt 文件，收集所有直接继承密封类的类。
2. 元数据生成：将子类列表序列化到 @Metadata 注解的 d2 数组。
3. when 检查：编译器解析 when 分支的 is 检查，与子类列表对比，缺失即报错。

Kotlin 2.0（K2 编译器）：

1. FIR 一次分析：K2 通过 FIR（Frontend Intermediate Representation）一次分析收集子类，避免 K1 的重复扫描。
2. 跨模块检查：K2 在跨模块使用密封类时，从依赖的 @Metadata 注解读取子类列表，正确检查穷举。
3. 智能分支合并：K2 能识别 is A -> ...; is B -> ... 与 is A, is B -> ... 的等价性，减少误报。

4.3 嵌套密封类的穷举传播

嵌套密封类的穷举检查规则：

sealed class UiState {
    object Loading : UiState()

    sealed class Content : UiState() {
        data class UserList(val users: List<User>) : Content()
        data class UserDetail(val user: User) : Content()
    }

    sealed class Error : UiState() {
        data class Network(val code: Int) : Error()
        data class Auth(val reason: String) : Error()
    }
}

穷举检查：

fun render(state: UiState) = when (state) {
    is UiState.Loading -> showLoading()
    is UiState.Content -> when (state) {  // 嵌套 when 继续穷举 Content
        is UiState.Content.UserList -> showUserList(state.users)
        is UiState.Content.UserDetail -> showUserDetail(state.user)
    }
    is UiState.Error -> when (state) {  // 嵌套 when 继续穷举 Error
        is UiState.Error.Network -> showNetworkError(state.code)
        is UiState.Error.Auth -> showAuthError(state.reason)
    }
}

编译器要求：

1. 外层 when 必须覆盖 Loading、Content、Error。
2. 内层 when 必须覆盖 Content 的子类与 Error 的子类（若内层 when 是表达式）。

替代写法（扁平化）：

fun render(state: UiState) = when (state) {
    is UiState.Loading -> showLoading()
    is UiState.Content.UserList -> showUserList(state.users)
    is UiState.Content.UserDetail -> showUserDetail(state.user)
    is UiState.Error.Network -> showNetworkError(state.code)
    is UiState.Error.Auth -> showAuthError(state.reason)
}

这种写法更简洁，编译器同样能识别穷举。

4.4 密封接口的多继承价值

密封接口支持多继承，这是密封类无法实现的：

sealed interface Drawable { fun draw() }
sealed interface Clickable { fun onClick() }
sealed interface Focusable { fun onFocus() }

data class Button(val label: String) : Drawable, Clickable, Focusable {
    override fun draw() { /* ... */ }
    override fun onClick() { /* ... */ }
    override fun onFocus() { /* ... */ }
}

data class Image(val url: String) : Drawable {
    override fun draw() { /* ... */ }
}

// 在不同的 when 中分别处理
fun handleDraw(d: Drawable) = when (d) {
    is Button -> drawButton(d)
    is Image -> drawImage(d)
}

fun handleClick(c: Clickable) = when (c) {
    is Button -> handleButtonClick(c)
}

每个密封接口的 when 独立检查穷举，新增 Image 不会影响 Clickable 的 when。

4.5 when 表达式 vs when 语句

when 作为表达式（有返回值）时强制穷举：

// 表达式：强制穷举
val msg: String = when (state) {
    is Loading -> "Loading"
    is Success -> "Success"
    is Error -> "Error"
}

when 作为语句（无返回值）时不强制穷举：

// 语句：不强制穷举
when (state) {
    is Loading -> showLoading()
    // 不报错，但可能遗漏 Success 与 Error
}

最佳实践：始终将 when 作为表达式使用，借助 val result = when (state) { ... } 强制穷举，即使不需要返回值。

4.6 object 子类与 data class 子类的差异

sealed class Result<out T> {
    data class Success<T>(val value: T) : Result<T>()
    data class Error(val message: String) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

fun handle(r: Result<Int>) = when (r) {
    is Result.Success -> println(r.value)  // r: Result.Success<Int>
    is Result.Error -> println(r.message)  // r: Result.Error
    Result.Loading -> println("Loading")    // r: Result.Loading（object 单例）
    // 注意：object 子类用 Result.Loading（不带 is），因为单例可直接比较
}

is vs 直接引用：

• is 用于类型检查，适用于 data class 与 class 子类。
• 直接引用（如 Result.Loading）用于 object 单例比较，等价于 ===。
• 两者均可触发穷举检查。

4.7 智能转换的边界

智能转换在 when 分支内有效，但有以下限制：

1. var 变量：智能转换可能失效（多线程下 var 可变）。
2. 跨函数：智能转换不跨函数边界。
3. 复杂表达式：is 后跟 && 或 || 时，智能转换可能不传播。

var state: Result<Int> = ...

when (state) {
    is Result.Success -> {
        // state: Result.Success<Int>？不一定！
        // 因为 state 是 var，可能在 is 检查后被其他线程修改
        // 但 Kotlin 在单线程上下文（如局部 var）中仍允许智能转换
        println(state.value)
    }
}

安全实践：对于可变属性，先赋给局部 val：

val currentState = state  // 快照
when (currentState) {
    is Result.Success -> println(currentState.value)  // 安全
}

4.8 密封类与 when 的编译器优化

Kotlin 编译器对 when 进行优化：

1. tableswitch 优化：若子类数量较多且分支条件是整数比较，编译器生成 tableswitch 字节码，$O(1)$ 跳转。
2. lookupswitch 优化：若分支条件是字符串或稀疏整数，编译器生成 lookupswitch。
3. if-else 链回退：若无法优化为 switch，编译器生成 if-else 链，$O(n)$ 比较。

示例：

sealed class Color { object RED; object GREEN; object BLUE }
fun name(c: Color) = when (c) {
    Color.RED -> "Red"
    Color.GREEN -> "Green"
    Color.BLUE -> "Blue"
}

字节码（简化）：

public static String name(Color c) {
    int id = c instanceof Color.RED ? 0 : (c instanceof Color.GREEN ? 1 : 2);
    switch (id) {
        case 0: return "Red";
        case 1: return "Green";
        case 2: return "Blue";
    }
}

4.9 密封类与递归数据结构

递归密封类（如表达式树、JSON 树）的形式化：

sealed class Json {
    data class Obj(val entries: Map<String, Json>) : Json()
    data class Arr(val elements: List<Json>) : Json()
    data class Str(val value: String) : Json()
    data class Num(val value: Double) : Json()
    data class Bool(val value: Boolean) : Json()
    object Null : Json()
}

fun stringify(json: Json): String = when (json) {
    is Json.Obj -> json.entries.entries.joinToString(",", "{", "}") { "\"${it.key}\":${stringify(it.value)}" }
    is Json.Arr -> json.elements.joinToString(",", "[", "]") { stringify(it) }
    is Json.Str -> "\"${json.value}\""
    is Json.Num -> json.value.toString()
    is Json.Bool -> json.value.toString()
    Json.Null -> "null"
}

递归 when 是 catamorphism（折叠）的实例，对树结构进行递归遍历。

4.10 Kotlin 2.0 K2 编译器的穷举检查改进

K2 编译器对穷举检查进行了多项改进：

1. null 分支识别：对可空密封类，K2 能识别 null 分支与 is 分支的组合：

sealed class Result
object Loading : Result()
data class Success(val value: Int) : Result()

fun handle(r: Result?) = when (r) {
    null -> println("Null")
    Result.Loading -> println("Loading")
    is Result.Success -> println(r.value)
}
// K2 识别 null 分支，穷举检查通过

2. is + !is 组合：K2 能识别 is A 与 !is A 的互补关系。

3. when 嵌套穷举传播：K2 能识别嵌套 when 的穷举传播，减少误报。

4. 跨模块一致性：K2 在 KMP 项目中保证 JVM、JS、Native 平台的穷举检查行为一致。

5. 代码示例

5.1 网络请求结果建模

/**
 * 网络请求结果的三态建模。
 * - Loading：请求进行中
 * - Success：请求成功，携带数据
 * - Error：请求失败，携带错误信息
 */
sealed class NetworkResult<out T> {
    object Loading : NetworkResult<Nothing>()
    data class Success<T>(val data: T) : NetworkResult<T>()
    data class Error(val message: String, val cause: Throwable? = null) : NetworkResult<Nothing>()
}

/**
 * 处理网络请求结果，穷举所有分支。
 */
fun <T> handleResult(result: NetworkResult<T>) {
    when (result) {
        NetworkResult.Loading -> println("Loading...")
        is NetworkResult.Success -> println("Success: ${result.data}")
        is NetworkResult.Error -> {
            println("Error: ${result.message}")
            result.cause?.printStackTrace()
        }
    }
}

fun main() {
    handleResult(NetworkResult.Loading)
    handleResult(NetworkResult.Success(42))
    handleResult(NetworkResult.Error("Network error"))
}

5.2 UI 状态建模（MVI 架构）

/**
 * 屏幕状态建模，覆盖空闲、加载、内容、错误四态。
 */
sealed class UiState<out T> {
    object Idle : UiState<Nothing>()
    object Loading : UiState<Nothing>()
    data class Content<T>(val data: T) : UiState<T>()
    data class Error(val message: String, val retry: () -> Unit) : UiState<Nothing>()
}

/**
 * 用户意图（Wish / Intent），MVI 架构的核心。
 */
sealed class UserWish {
    data class LoadUser(val id: String) : UserWish()
    data class UpdateUser(val name: String) : UserWish()
    object Refresh : UserWish()
    object Logout : UserWish()
}

/**
 * 副作用（Effect），如导航、显示 Toast。
 */
sealed class UserEffect {
    data class ShowToast(val message: String) : UserEffect()
    data class Navigate(val route: String) : UserEffect()
}

class UserViewModel : ViewModel() {
    private val _state = MutableStateFlow<UiState<User>>(UiState.Idle)
    val state: StateFlow<UiState<User>> = _state.asStateFlow()

    private val _effects = Channel<UserEffect>(Channel.BUFFERED)
    val effects = _effects.receiveAsFlow()

    fun accept(wish: UserWish) {
        when (wish) {
            is UserWish.LoadUser -> loadUser(wish.id)
            is UserWish.UpdateUser -> updateUser(wish.name)
            UserWish.Refresh -> refresh()
            UserWish.Logout -> {
                _state.value = UiState.Idle
                _effects.trySend(UserEffect.Navigate("/login"))
            }
        }
    }

    private fun loadUser(id: String) {
        viewModelScope.launch {
            _state.value = UiState.Loading
            _state.value = try {
                UiState.Content(repository.fetchUser(id))
            } catch (e: Exception) {
                UiState.Error(e.message ?: "Unknown error") { loadUser(id) }
            }
        }
    }

    private fun updateUser(name: String) { /* ... */ }
    private fun refresh() { /* ... */ }
}

5.3 表达式树求值（递归密封类）

/**
 * 算术表达式的 AST 节点。
 */
sealed class Expr {
    data class Const(val value: Double) : Expr()
    data class Var(val name: String) : Expr()
    data class Sum(val left: Expr, val right: Expr) : Expr()
    data class Mul(val left: Expr, val right: Expr) : Expr()
    data class Neg(val expr: Expr) : Expr()
    data class Div(val numerator: Expr, val denominator: Expr) : Expr()
}

/**
 * 求值函数，递归遍历 AST。
 * @param env 变量环境，name -> value
 * @return 表达式的值
 */
fun eval(expr: Expr, env: Map<String, Double> = emptyMap()): Double = when (expr) {
    is Expr.Const -> expr.value
    is Expr.Var -> env[expr.name] ?: error("Undefined variable: ${expr.name}")
    is Expr.Sum -> eval(expr.left, env) + eval(expr.right, env)
    is Expr.Mul -> eval(expr.left, env) * eval(expr.right, env)
    is Expr.Neg -> -eval(expr.expr, env)
    is Expr.Div -> {
        val d = eval(expr.denominator, env)
        if (d == 0.0) error("Division by zero")
        eval(expr.numerator, env) / d
    }
}

/**
 * 表达式简化（代数化简）。
 */
fun simplify(expr: Expr): Expr = when (expr) {
    is Expr.Sum -> {
        val l = simplify(expr.left)
        val r = simplify(expr.right)
        when {
            l is Expr.Const && l.value == 0.0 -> r
            r is Expr.Const && r.value == 0.0 -> l
            l is Expr.Const && r is Expr.Const -> Expr.Const(l.value + r.value)
            else -> Expr.Sum(l, r)
        }
    }
    is Expr.Mul -> {
        val l = simplify(expr.left)
        val r = simplify(expr.right)
        when {
            l is Expr.Const && l.value == 0.0 -> Expr.Const(0.0)
            r is Expr.Const && r.value == 0.0 -> Expr.Const(0.0)
            l is Expr.Const && l.value == 1.0 -> r
            r is Expr.Const && r.value == 1.0 -> l
            l is Expr.Const && r is Expr.Const -> Expr.Const(l.value * r.value)
            else -> Expr.Mul(l, r)
        }
    }
    is Expr.Neg -> {
        val e = simplify(expr.expr)
        when (e) {
            is Expr.Const -> Expr.Const(-e.value)
            is Expr.Neg -> e.expr  // 双重否定消除
            else -> Expr.Neg(e)
        }
    }
    else -> expr
}

fun main() {
    // (1 + 2) * (3 + 4) = 21
    val expr = Expr.Mul(
        Expr.Sum(Expr.Const(1.0), Expr.Const(2.0)),
        Expr.Sum(Expr.Const(3.0), Expr.Const(4.0))
    )
    println(eval(expr))  // 21.0

    // 简化：0 + x = x
    val simplified = simplify(Expr.Sum(Expr.Const(0.0), Expr.Var("x")))
    println(simplified)  // Var(name=x)
}

5.4 JSON 树建模与遍历

/**
 * JSON 数据结构的 AST。
 */
sealed class Json {
    data class Obj(val entries: List<Pair<String, Json>>) : Json() {
        operator fun get(key: String): Json? = entries.firstOrNull { it.first == key }?.second
    }
    data class Arr(val elements: List<Json>) : Json()
    data class Str(val value: String) : Json()
    data class Num(val value: Double) : Json()
    data class Bool(val value: Boolean) : Json()
    object Null : Json()
}

/**
 * JSON 序列化为字符串。
 */
fun Json.stringify(indent: Int = 0): String {
    val pad = "  ".repeat(indent)
    return when (this) {
        is Json.Obj -> "{\n" + entries.joinToString(",\n") { "$pad  \"${it.first}\": ${it.second.stringify(indent + 1)}" } + "\n$pad}"
        is Json.Arr -> "[\n" + elements.joinToString(",\n") { "$pad  ${it.stringify(indent + 1)}" } + "\n$pad]"
        is Json.Str -> "\"$value\""
        is Json.Num -> value.toString()
        is Json.Bool -> value.toString()
        Json.Null -> "null"
    }
}

/**
 * 访问者模式遍历 JSON。
 */
fun Json.accept(visitor: JsonVisitor) {
    when (this) {
        is Json.Obj -> {
            visitor.visitObject(this)
            entries.forEach { (_, v) -> v.accept(visitor) }
        }
        is Json.Arr -> {
            visitor.visitArray(this)
            elements.forEach { it.accept(visitor) }
        }
        is Json.Str -> visitor.visitString(this)
        is Json.Num -> visitor.visitNumber(this)
        is Json.Bool -> visitor.visitBoolean(this)
        Json.Null -> visitor.visitNull()
    }
}

interface JsonVisitor {
    fun visitObject(obj: Json.Obj) {}
    fun visitArray(arr: Json.Arr) {}
    fun visitString(str: Json.Str) {}
    fun visitNumber(num: Json.Num) {}
    fun visitBoolean(bool: Json.Bool) {}
    fun visitNull() {}
}

fun main() {
    val json = Json.Obj(
        listOf(
            "name" to Json.Str("Alice"),
            "age" to Json.Num(30.0),
            "hobbies" to Json.Arr(listOf(Json.Str("Reading"), Json.Str("Hiking"))),
            "active" to Json.Bool(true)
        )
    )
    println(json.stringify())
}

5.5 密封接口多继承

/**
 * 多继承密封接口示例。
 */
sealed interface Drawable { fun draw(): String }
sealed interface Clickable { fun onClick(): String }
sealed interface Focusable { fun onFocus(): String }

data class Button(val label: String) : Drawable, Clickable, Focusable {
    override fun draw() = "Button($label) drawn"
    override fun onClick() = "Button($label) clicked"
    override fun onFocus() = "Button($label) focused"
}

data class Image(val url: String) : Drawable {
    override fun draw() = "Image($url) drawn"
}

data class TextField(val text: String) : Drawable, Clickable, Focusable {
    override fun draw() = "TextField drawn"
    override fun onClick() = "TextField clicked"
    override fun onFocus() = "TextField focused"
}

object Divider : Drawable {
    override fun draw() = "Divider drawn"
}

/**
 * 处理可绘制对象，穷举所有 Drawable 子类。
 */
fun render(d: Drawable): String = when (d) {
    is Button -> "Rendering: ${d.draw()}"
    is Image -> "Rendering: ${d.draw()}"
    is TextField -> "Rendering: ${d.draw()}"
    Divider -> "Rendering: ${d.draw()}"
}

/**
 * 处理可点击对象，穷举所有 Clickable 子类。
 * 注意：Image 与 Divider 不实现 Clickable，不在分支中。
 */
fun handleClick(c: Clickable): String = when (c) {
    is Button -> c.onClick()
    is TextField -> c.onClick()
}

fun main() {
    println(render(Button("Submit")))    // Rendering: Button(Submit) drawn
    println(render(Image("logo.png")))   // Rendering: Image(logo.png) drawn
    println(handleClick(Button("OK")))   // Button(OK) clicked
}

5.6 状态机建模

/**
 * 订单状态机。
 */
sealed class OrderState {
    object Created : OrderState()
    data class Paid(val amount: Double, val paidAt: Long) : OrderState()
    data class Shipped(val trackingNo: String, val shippedAt: Long) : OrderState()
    data class Delivered(val deliveredAt: Long) : OrderState()
    data class Cancelled(val reason: String, val cancelledAt: Long) : OrderState()
}

/**
 * 状态转换事件。
 */
sealed class OrderEvent {
    data class Pay(val amount: Double) : OrderEvent()
    data class Ship(val trackingNo: String) : OrderEvent()
    object Deliver : OrderEvent()
    data class Cancel(val reason: String) : OrderEvent()
}

/**
 * 状态转换函数，穷举所有 state × event 组合。
 * 不可能的转换抛出 IllegalStateException。
 */
fun transition(state: OrderState, event: OrderEvent): OrderState = when (state) {
    OrderState.Created -> when (event) {
        is OrderEvent.Pay -> OrderState.Paid(event.amount, System.currentTimeMillis())
        is OrderEvent.Cancel -> OrderState.Cancelled(event.reason, System.currentTimeMillis())
        is OrderEvent.Ship -> error("Cannot ship unpaid order")
        OrderEvent.Deliver -> error("Cannot deliver unpaid order")
    }
    is OrderState.Paid -> when (event) {
        is OrderEvent.Ship -> OrderState.Shipped(event.trackingNo, System.currentTimeMillis())
        is OrderEvent.Cancel -> OrderState.Cancelled(event.reason, System.currentTimeMillis())
        is OrderEvent.Pay -> error("Order already paid")
        OrderEvent.Deliver -> error("Cannot deliver unshipped order")
    }
    is OrderState.Shipped -> when (event) {
        OrderEvent.Deliver -> OrderState.Delivered(System.currentTimeMillis())
        is OrderEvent.Cancel -> error("Cannot cancel shipped order")
        is OrderEvent.Pay -> error("Order already paid")
        is OrderEvent.Ship -> error("Order already shipped")
    }
    is OrderState.Delivered -> when (event) {
        // 终态，不接受任何事件
        is OrderEvent.Pay, is OrderEvent.Ship, OrderEvent.Deliver, is OrderEvent.Cancel ->
            error("Order already delivered, terminal state")
    }
    is OrderState.Cancelled -> when (event) {
        // 终态，不接受任何事件
        is OrderEvent.Pay, is OrderEvent.Ship, OrderEvent.Deliver, is OrderEvent.Cancel ->
            error("Order already cancelled, terminal state")
    }
}

fun main() {
    var state: OrderState = OrderState.Created
    state = transition(state, OrderEvent.Pay(99.0))
    println(state)  // Paid(amount=99.0, ...)
    state = transition(state, OrderEvent.Ship("SF123456"))
    println(state)  // Shipped(trackingNo=SF123456, ...)
    state = transition(state, OrderEvent.Deliver)
    println(state)  // Delivered(...)
}

5.7 密封类与序列化

import kotlinx.serialization.*
import kotlinx.serialization.json.*

/**
 * 消息类型的多态序列化。
 */
@Serializable
sealed class Message {
    @Serializable
    @SerialName("text")
    data class Text(val content: String, val author: String) : Message()

    @Serializable
    @SerialName("image")
    data class Image(val url: String, val width: Int, val height: Int, val author: String) : Message()

    @Serializable
    @SerialName("system")
    data class SystemNotice(val action: String, val timestamp: Long) : Message()

    @Serializable
    @SerialName("sticker")
    data class Sticker(val stickerId: String, val author: String) : Message()
}

fun main() {
    val json = Json {
        ignoreUnknownKeys = true
        classDiscriminator = "type"  // 类鉴别器字段名
    }

    // 序列化
    val messages: List<Message> = listOf(
        Message.Text("Hello", "Alice"),
        Message.Image("https://example.com/1.png", 800, 600, "Bob"),
        Message.SystemNotice("user_joined", System.currentTimeMillis()),
        Message.Sticker("sticker_001", "Alice")
    )

    val jsonString = json.encodeToString(messages)
    println(jsonString)

    // 反序列化
    val decoded = json.decodeFromString<List<Message>>(jsonString)
    decoded.forEach { msg ->
        when (msg) {
            is Message.Text -> println("[Text] ${msg.author}: ${msg.content}")
            is Message.Image -> println("[Image] ${msg.author}: ${msg.url}")
            is Message.SystemNotice -> println("[System] ${msg.action} at ${msg.timestamp}")
            is Message.Sticker -> println("[Sticker] ${msg.author}: ${msg.stickerId}")
        }
    }
}

5.8 嵌套密封类分层处理

/**
 * 嵌套密封类：分层建模复杂状态。
 */
sealed class AppState {
    object Splash : AppState()

    sealed class Auth : AppState() {
        object Login : Auth()
        object Register : Auth()
        data class ForgotPassword(val email: String) : Auth()
    }

    sealed class Main : AppState() {
        data class Home(val tabIndex: Int) : Main()
        data class Profile(val userId: String) : Main()
        data class Settings(val section: String) : Main()
    }

    sealed class Error : AppState() {
        data class Network(val code: Int) : Error()
        data class Server(val message: String) : Error()
        object Unknown : Error()
    }
}

/**
 * 分层处理：外层 when 穷举顶层子类，内层 when 穷举嵌套子类。
 */
fun handleState(state: AppState) {
    when (state) {
        AppState.Splash -> showSplash()
        is AppState.Auth -> when (state) {
            is AppState.Auth.Login -> showLogin()
            is AppState.Auth.Register -> showRegister()
            is AppState.Auth.ForgotPassword -> showForgotPassword(state.email)
        }
        is AppState.Main -> when (state) {
            is AppState.Main.Home -> showHome(state.tabIndex)
            is AppState.Main.Profile -> showProfile(state.userId)
            is AppState.Main.Settings -> showSettings(state.section)
        }
        is AppState.Error -> when (state) {
            is AppState.Error.Network -> showNetworkError(state.code)
            is AppState.Error.Server -> showServerError(state.message)
            AppState.Error.Unknown -> showUnknownError()
        }
    }
}

fun showSplash() {}
fun showLogin() {}
fun showRegister() {}
fun showForgotPassword(email: String) {}
fun showHome(tab: Int) {}
fun showProfile(userId: String) {}
fun showSettings(section: String) {}
fun showNetworkError(code: Int) {}
fun showServerError(message: String) {}
fun showUnknownError() {}

5.9 密封类与 @SerialName 多态序列化

/**
 * 跨平台 API 响应的多态序列化。
 */
@Serializable
sealed class ApiResponse<out T> {
    @Serializable
    @SerialName("success")
    data class Success<T>(val data: T, val timestamp: Long) : ApiResponse<T>()

    @Serializable
    @SerialName("error")
    data class Error(val code: Int, val message: String) : ApiResponse<Nothing>()

    @Serializable
    @SerialName("empty")
    object Empty : ApiResponse<Nothing>()
}

@Serializable
data class User(val id: String, val name: String)

fun main() {
    val json = Json { ignoreUnknownKeys = true }

    // 模拟 API 响应
    val successJson = """{"type":"success","data":{"id":"1","name":"Alice"},"timestamp":1700000000}"""
    val errorJson = """{"type":"error","code":404,"message":"Not Found"}"""
    val emptyJson = """{"type":"empty"}"""

    val success: ApiResponse<User> = json.decodeFromString(successJson)
    val error: ApiResponse<User> = json.decodeFromString(errorJson)
    val empty: ApiResponse<User> = json.decodeFromString(emptyJson)

    listOf(success, error, empty).forEach { response ->
        val msg = when (response) {
            is ApiResponse.Success -> "OK: ${response.data}"
            is ApiResponse.Error -> "Error ${response.code}: ${response.message}"
            ApiResponse.Empty -> "Empty response"
        }
        println(msg)
    }
}

5.10 密封接口与枚举组合

/**
 * 密封接口允许枚举作为子类型。
 */
sealed interface Color {
    val rgb: Int
}

enum class BasicColor(override val rgb: Int) : Color {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF)
}

data class CustomColor(val name: String, override val rgb: Int) : Color

data class GradientColor(val from: Color, val to: Color) : Color {
    override val rgb: Int = from.rgb  // 简化：使用起始色
}

fun describe(c: Color): String = when (c) {
    BasicColor.RED -> "Red"
    BasicColor.GREEN -> "Green"
    BasicColor.BLUE -> "Blue"
    is CustomColor -> "Custom: ${c.name}"
    is GradientColor -> "Gradient from ${describe(c.from)} to ${describe(c.to)}"
}

fun main() {
    println(describe(BasicColor.RED))  // Red
    println(describe(CustomColor("Magenta", 0xFF00FF)))  // Custom: Magenta
    println(describe(GradientColor(BasicColor.RED, BasicColor.BLUE)))  // Gradient from Red to Blue
}

5.11 密封类与 copy 实现状态更新

/**
 * 表单状态，使用 copy 实现不可变更新。
 */
sealed class FormState {
    data class Empty(val fields: Map<String, String>) : FormState()
    data class PartiallyFilled(val fields: Map<String, String>, val validFields: Int) : FormState()
    data class Complete(val fields: Map<String, String>) : FormState()
    data class Invalid(val fields: Map<String, String>, val errors: List<String>) : FormState()
    object Submitting : FormState()
    data class Submitted(val responseId: String) : FormState()
}

/**
 * 表单事件。
 */
sealed class FormEvent {
    data class UpdateField(val key: String, val value: String) : FormEvent()
    object Validate : FormEvent()
    object Submit : FormEvent()
    data class SubmitSuccess(val responseId: String) : FormEvent()
    data class SubmitError(val error: String) : FormEvent()
}

/**
 * 状态更新函数，穷举所有 state × event 组合。
 */
fun update(state: FormState, event: FormEvent): FormState = when (state) {
    is FormState.Empty -> when (event) {
        is FormEvent.UpdateField -> {
            val newFields = state.fields + (event.key to event.value)
            FormState.PartiallyFilled(newFields, newFields.count { it.value.isNotBlank() })
        }
        FormEvent.Validate -> state  // 无字段可验证
        FormEvent.Submit -> FormState.Invalid(state.fields, listOf("Form is empty"))
        is FormEvent.SubmitSuccess, is FormEvent.SubmitError -> state
    }
    is FormState.PartiallyFilled -> when (event) {
        is FormEvent.UpdateField -> {
            val newFields = state.fields + (event.key to event.value)
            state.copy(fields = newFields, validFields = newFields.count { it.value.isNotBlank() })
        }
        FormEvent.Validate -> {
            val errors = state.fields.filter { it.value.isBlank() }.map { "Field ${it.key} is required" }
            if (errors.isEmpty()) FormState.Complete(state.fields) else FormState.Invalid(state.fields, errors)
        }
        FormEvent.Submit -> FormState.Submitting
        is FormEvent.SubmitSuccess, is FormEvent.SubmitError -> state
    }
    is FormState.Complete -> when (event) {
        is FormEvent.UpdateField -> {
            val newFields = state.fields + (event.key to event.value)
            FormState.PartiallyFilled(newFields, newFields.count { it.value.isNotBlank() })
        }
        FormEvent.Validate -> state  // 已完整
        FormEvent.Submit -> FormState.Submitting
        is FormEvent.SubmitSuccess, is FormEvent.SubmitError -> state
    }
    is FormState.Invalid -> when (event) {
        is FormEvent.UpdateField -> {
            val newFields = state.fields + (event.key to event.value)
            FormState.PartiallyFilled(newFields, newFields.count { it.value.isNotBlank() })
        }
        FormEvent.Validate -> {
            val errors = state.fields.filter { it.value.isBlank() }.map { "Field ${it.key} is required" }
            if (errors.isEmpty()) FormState.Complete(state.fields) else state.copy(errors = errors)
        }
        FormEvent.Submit -> state  // 不允许提交
        is FormEvent.SubmitSuccess, is FormEvent.SubmitError -> state
    }
    FormState.Submitting -> when (event) {
        is FormEvent.SubmitSuccess -> FormState.Submitted(event.responseId)
        is FormEvent.SubmitError -> FormState.Invalid(emptyMap(), listOf(event.error))
        is FormEvent.UpdateField, FormEvent.Validate, FormEvent.Submit -> state  // 提交中忽略其他事件
    }
    is FormState.Submitted -> when (event) {
        // 终态，忽略所有事件
        is FormEvent.UpdateField, FormEvent.Validate, FormEvent.Submit,
        is FormEvent.SubmitSuccess, is FormEvent.SubmitError -> state
    }
}

5.12 密封类实现 Result 类型

/**
 * 类似 Rust Result 的类型，用密封类实现。
 */
sealed class Result<out T, out E> {
    data class Ok<out T>(val value: T) : Result<T, Nothing>()
    data class Err<out E>(val error: E) : Result<Nothing, E>()

    inline fun <R> map(f: (T) -> R): Result<R, E> = when (this) {
        is Ok -> Ok(f(value))
        is Err -> this
    }

    inline fun <R> flatMap(f: (T) -> Result<R, E>): Result<R, E> = when (this) {
        is Ok -> f(value)
        is Err -> this
    }

    inline fun <R> mapError(f: (E) -> R): Result<T, R> = when (this) {
        is Ok -> this
        is Err -> Err(f(error))
    }

    inline fun getOrElse(default: (E) -> T): T = when (this) {
        is Ok -> value
        is Err -> default(error)
    }

    inline fun <R> fold(onOk: (T) -> R, onErr: (E) -> R): R = when (this) {
        is Ok -> onOk(value)
        is Err -> onErr(error)
    }
}

/**
 * 错误类型。
 */
sealed class AppError {
    data class Network(val code: Int, val message: String) : AppError()
    data class Validation(val field: String, val reason: String) : AppError()
    data class Database(val query: String, val cause: Throwable) : AppError()
    object Unauthorized : AppError()
    object NotFound : AppError()
}

/**
 * 模拟用户获取，返回 Result 类型。
 */
fun fetchUser(id: String): Result<User, AppError> {
    if (id.isBlank()) return Result.Err(AppError.Validation("id", "ID cannot be blank"))
    if (id == "404") return Result.Err(AppError.NotFound)
    return Result.Ok(User(id, "User$id"))
}

fun main() {
    val result = fetchUser("1")
        .map { it.copy(name = it.name.uppercase()) }
        .flatMap { user ->
            if (user.name.startsWith("USER")) Result.Ok(user)
            else Result.Err(AppError.Validation("name", "Invalid format"))
        }

    val msg = result.fold(
        onOk = { "Got user: $it" },
        onErr = { err ->
            when (err) {
                is AppError.Network -> "Network error: ${err.code} ${err.message}"
                is AppError.Validation -> "Validation error: ${err.field} - ${err.reason}"
                is AppError.Database -> "Database error: ${err.query}"
                AppError.Unauthorized -> "Unauthorized"
                AppError.NotFound -> "Not Found"
            }
        }
    )
    println(msg)
}

5.13 密封类与 KMP 跨平台

// commonMain/NetworkResult.kt
package com.example.network

/**
 * 跨平台共享的网络结果类型。
 */
sealed class NetworkResult<out T> {
    data class Success<T>(val data: T) : NetworkResult<T>()
    data class Error(val code: Int, val message: String) : NetworkResult<Nothing>()
    object Loading : NetworkResult<Nothing>()
}

// commonMain/ApiService.kt
package com.example.network

interface ApiService {
    suspend fun fetchUser(id: String): NetworkResult<User>
}

// commonMain/ResultProcessor.kt
package com.example.network

/**
 * 跨平台共享的结果处理逻辑。
 */
fun <T> NetworkResult<T>.handle(
    onSuccess: (T) -> Unit,
    onError: (Int, String) -> Unit,
    onLoading: () -> Unit
) {
    when (this) {
        is NetworkResult.Success -> onSuccess(data)
        is NetworkResult.Error -> onError(code, message)
        NetworkResult.Loading -> onLoading()
    }
}

// androidMain/AndroidApiService.kt
package com.example.network

class AndroidApiService(private val retrofit: Retrofit) : ApiService {
    override suspend fun fetchUser(id: String): NetworkResult<User> = try {
        NetworkResult.Success(retrofit.create(UserApi::class.java).getUser(id))
    } catch (e: HttpException) {
        NetworkResult.Error(e.code(), e.message())
    } catch (e: Exception) {
        NetworkResult.Error(-1, e.message ?: "Unknown error")
    }
}

// iosMain/IosApiService.kt
package com.example.network

class IosApiService : ApiService {
    override suspend fun fetchUser(id: String): NetworkResult<User> {
        // iOS 实现，使用 NSURLSession
        TODO("Implement with NSURLSession")
    }
}

5.14 密封类实现命令模式

/**
 * 命令模式：用密封类建模所有用户操作。
 */
sealed class Command {
    data class Create(val key: String, val value: String) : Command()
    data class Update(val key: String, val value: String) : Command()
    data class Delete(val key: String) : Command()
    data class Move(val fromKey: String, val toKey: String) : Command()
    object Undo : Command()
    object Redo : Command()
}

/**
 * 命令执行器，穷举所有命令类型。
 */
class CommandExecutor {
    private val data = mutableMapOf<String, String>()
    private val undoStack = ArrayDeque<() -> Unit>()
    private val redoStack = ArrayDeque<() -> Unit>()

    fun execute(cmd: Command) {
        when (cmd) {
            is Command.Create -> {
                val oldValue = data.put(cmd.key, cmd.value)
                undoStack.addLast { oldValue?.let { data[cmd.key] = it } ?: data.remove(cmd.key) }
            }
            is Command.Update -> {
                val oldValue = data[cmd.key]
                data[cmd.key] = cmd.value
                undoStack.addLast { if (oldValue != null) data[cmd.key] = oldValue }
            }
            is Command.Delete -> {
                val oldValue = data.remove(cmd.key)
                undoStack.addLast { if (oldValue != null) data[cmd.key] = oldValue }
            }
            is Command.Move -> {
                val fromValue = data.remove(cmd.fromKey)
                if (fromValue != null) {
                    val toOldValue = data.put(cmd.toKey, fromValue)
                    undoStack.addLast {
                        if (toOldValue != null) data[cmd.toKey] = toOldValue else data.remove(cmd.toKey)
                        data[cmd.fromKey] = fromValue
                    }
                }
            }
            Command.Undo -> {
                undoStack.removeLastOrNull()?.let { undo ->
                    redoStack.addLast { undo() }  // 简化：实际 undo/redo 更复杂
                    undo()
                }
            }
            Command.Redo -> {
                redoStack.removeLastOrNull()?.invoke()
            }
        }
    }
}

5.15 密封类与递归下降解析器

/**
 * 简单的 Token 类型，用密封类表示。
 */
sealed class Token {
    data class Number(val value: Double) : Token()
    data class Identifier(val name: String) : Token()
    object Plus : Token()
    object Minus : Token()
    object Star : Token()
    object Slash : Token()
    object LParen : Token()
    object RParen : Token()
    object EOF : Token()
}

/**
 * AST 节点。
 */
sealed class Ast {
    data class Number(val value: Double) : Ast()
    data class Var(val name: String) : Ast()
    data class BinOp(val op: String, val left: Ast, val right: Ast) : Ast()
    data class UnaryOp(val op: String, val expr: Ast) : Ast()
}

/**
 * 递归下降解析器。
 */
class Parser(private val tokens: List<Token>) {
    private var pos = 0

    fun parse(): Ast = parseExpr()

    private fun parseExpr(): Ast {
        var left = parseTerm()
        while (peek() is Token.Plus || peek() is Token.Minus) {
            val op = if (next() is Token.Plus) "+" else "-"
            val right = parseTerm()
            left = Ast.BinOp(op, left, right)
        }
        return left
    }

    private fun parseTerm(): Ast {
        var left = parseFactor()
        while (peek() is Token.Star || peek() is Token.Slash) {
            val op = if (next() is Token.Star) "*" else "/"
            val right = parseFactor()
            left = Ast.BinOp(op, left, right)
        }
        return left
    }

    private fun parseFactor(): Ast {
        return when (val t = peek()) {
            is Token.Number -> {
                next()
                Ast.Number(t.value)
            }
            is Token.Identifier -> {
                next()
                Ast.Var(t.name)
            }
            Token.LParen -> {
                next()
                val expr = parseExpr()
                require(next() == Token.RParen) { "Expected )" }
                expr
            }
            Token.Minus -> {
                next()
                Ast.UnaryOp("-", parseFactor())
            }
            Token.Plus, Token.Star, Token.Slash, Token.RParen, Token.EOF ->
                error("Unexpected token: $t")
        }
    }

    private fun peek(): Token = tokens.getOrElse(pos) { Token.EOF }
    private fun next(): Token = tokens[pos++]
}

fun main() {
    val tokens = listOf(
        Token.Number(1.0), Token.Plus, Token.Number(2.0), Token.Star,
        Token.Number(3.0), Token.EOF
    )
    val ast = Parser(tokens).parse()
    println(ast)  // BinOp(op=+, left=Number(1.0), right=BinOp(op=*, ...))
}