密封类与密封接口

前置知识#

• Channel 与 BroadcastChannel：建议先完成前一篇的学习

学习目标#

• 掌握「1. 历史动机与发展脉络」的核心机制、典型用法与常见陷阱
• 掌握「2. 形式化定义」的核心机制、典型用法与常见陷阱
• 掌握「3. 理论推导与原理解析」的核心机制、典型用法与常见陷阱
• 掌握「4. 代码示例」的核心机制、典型用法与常见陷阱
• 掌握「5. 对比分析」的核心机制、典型用法与常见陷阱

1. 历史动机与发展脉络#

1.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 中的分支变为死代码，难以发现。

1.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。

1.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 作为表达式使用时生效。

1.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. 子类必须直接继承密封类（不能跨中间抽象层）。

1.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 表达式穷举检查覆盖密封接口的所有实现类。

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

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

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

1.7 Kotlin 1.9（2023）：K2 兼容#

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

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

1.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 分支骨架。

1.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 的对比：

1.10 时间线总览#

2. 形式化定义#

2.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）。

2.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）

形式化：

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

2.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 兜底。

2.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

2.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 表达式按声明顺序匹配，第一个匹配的分支被执行。这意味着更具体的分支应放在更一般的分支之前。

2.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$ 本身是抽象的）。

2.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
        }
    }
}

2.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.

2.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>。

2.10 递归密封类的形式化#

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

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

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

3. 理论推导与原理解析#

3.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，避免遗漏。

3.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 -> ... 的等价性，减少误报。

3.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)
}

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

3.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。

3.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) { ... } 强制穷举，即使不需要返回值。

3.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 单例比较，等价于 ===。
• 两者均可触发穷举检查。

3.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)  // 安全
}

3.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";
    }
}

3.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（折叠）的实例，对树结构进行递归遍历。

3.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 平台的穷举检查行为一致。

4. 代码示例#

4.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"))
}

4.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() { /* ... */ }
}

4.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)
}

4.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())
}

4.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
}

4.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(...)
}

4.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}")
        }
    }
}

4.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() {}

4.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)
    }
}

4.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
}

4.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
    }
}

4.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)
}

4.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")
    }
}

4.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()
            }
        }
    }
}

4.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=*, ...))
}