扩展函数的编译原理

本文档对标 MIT 6.005、Stanford CS193P、CMU 15-410 教学水准，系统讲解 Kotlin 扩展函数（Extension Functions）从语言设计到 JVM 字节码实现的完整链路。内容覆盖 Kotlin 1.0 至 2.0 K2 编译器的演进，配套企业级生产代码、跨语言对比、形式化推导与习题解析。

目录

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

1. 学习目标

本章节遵循 Bloom 教育目标分类学（Bloom’s Taxonomy）的六个认知层级，由低阶到高阶逐层递进，覆盖记忆、理解、应用、分析、评价与创造六个维度。

1.1 Remember（记忆）

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

• 复述 Kotlin 扩展函数的语法形式 fun ReceiverType.funcName(): ReturnType。
• 列举扩展函数编译为 JVM 字节码时的三个核心要素：静态方法、接收者参数、@JvmName 注解。
• 背诵扩展函数与成员函数的优先级规则：成员函数优先于扩展函数。
• 列出 Kotlin 2.0 K2 编译器相对于 K1 的三大改进方向：统一编译器前端、性能提升、诊断信息优化。
• 记忆扩展属性（Extension Property）不能有 initializer、不能有 backing field 的两条硬性约束。

1.2 Understand（理解）

完成本章节后，学习者应能够解释以下概念：

• 用自己的语言解释”扩展函数不修改原类”这一设计哲学的语义含义与实现机制。
• 描述静态分发（Static Dispatch）与动态分发（Dynamic Dispatch）在扩展函数上下文中的区别，并能画出分发流程图。
• 解释 this 关键字在扩展函数中的作用域：它指向接收者实例，但其可见性受 private 修饰符限制。
• 阐述 nullable 接收者（Nullable Receiver）fun String?.isNullOrBlank() 的工作原理，并能说明其与空安全的关系。
• 理解为什么扩展函数在泛型场景下会退化为 Object 接收者（类型擦除）。

1.3 Apply（应用）

完成本章节后，学习者应能够在以下场景中应用扩展函数：

• 在 Android 项目中为 View、Context、String 等系统类添加扩展函数，简化 UI 代码。
• 在后端 Ktor 项目中使用扩展函数为 HttpRequest、HttpResponse 添加业务无关的工具方法。
• 在 Gradle 构建脚本中使用 @JvmName 解决扩展函数与 Java 静态方法命名冲突。
• 在测试代码中使用扩展函数封装断言逻辑，提升测试可读性。
• 在 DSL 构建器中利用扩展函数实现层次化 API（如 HTML DSL、SQL DSL）。

1.4 Analyze（分析）

完成本章节后，学习者应能够进行以下分析：

• 反编译一段 Kotlin 代码，分析扩展函数编译后的字节码结构，识别接收者参数、桥接方法、内联标记。
• 对比同一问题在”扩展函数方案”、“成员函数方案”、“工具类静态方法方案”下的字节码体积与运行时性能。
• 分析 kotlin-stdlib 中 String.isNotBlank()、List<T>.windowed() 等扩展函数的实现源码，总结其设计模式。
• 解构 Kotlin 标准库 let、run、apply、also、with 五个作用域函数的本质，证明它们都是基于扩展函数与内联函数实现的。

1.5 Evaluate（评价）

完成本章节后，学习者应能够评价以下设计决策：

• 评价 JetBrains 在扩展函数中采用”静态分发”而非”动态分发”的设计权衡，从类型安全、性能、二进制兼容性三个维度论证。
• 评价 C# 的扩展方法（Extension Methods）与 Kotlin 扩展函数在可见性、命名空间导入机制上的差异，并指出各自优劣。
• 评价扩展函数在库设计中作为公共 API 的风险：版本兼容性、命名冲突、IDE 自动补全污染。
• 评价 Kotlin 2.0 K2 编译器对扩展函数解析顺序的微调（如更严格的 @SinceKotlin 检查），并判断其对现有代码迁移的影响。

1.6 Create（创造）

完成本章节后，学习者应能够创造以下作品：

• 设计并实现一个类型安全的 SQL DSL 库，使用扩展函数 + 内联函数 + 类型参数约束实现编译期 SQL 语法检查。
• 设计一个跨平台的日志门面（Logging Facade），使用扩展函数为 Any、Result<T>、Throwable 添加结构化日志能力。
• 实现一个迷你 Kotlin 编译器插件（Compiler Plugin），在 IR 阶段对特定扩展函数进行字节码织入（Bytecode Weaving）。
• 撰写一份扩展函数在团队代码规范中的使用指南，明确”何时使用扩展函数、何时使用成员函数”的决策树。

2. 历史动机与发展脉络

2.1 问题背景：表达问题（Expression Problem）

扩展函数的诞生，根植于编程语言理论中著名的表达问题（The Expression Problem），又称可扩展性问题。该问题由 Philip Wadler 在 1998 年的论文《The Expression Problem》中正式命名，但其思想可追溯至 Reynolds 1975 年关于用户定义类型的论文。

表达问题可以表述为：能否在不重新编译已有代码的前提下，既为封闭数据类型添加新变体（Variant），又为其添加新操作（Operation）？

• 面向对象范式：易于添加新变体（子类继承），但难以添加新操作（需要修改所有子类）。
• 函数式范式：易于添加新操作（模式匹配 + 函数），但难以添加新变体（需要修改所有 match 分支）。

            添加新变体      添加新操作
OOP         容易             困难（需修改所有子类）
FP          困难（需修改match） 容易
扩展函数     困难（不能继承）   容易（外部静态方法）

Kotlin 扩展函数是一种”半开半闭”的解决方案：它允许在不修改原类的前提下添加新操作，但牺牲了对新变体的支持（因为扩展函数是静态分发的，不具备多态性）。

2.2 Kotlin 1.0（2016 年 2 月首发）：扩展函数的初始形态

Kotlin 1.0 于 2016 年 2 月 15 日正式发布，扩展函数作为语言核心特性之一首次亮相。其设计灵感主要来源于：

1. C# 的 Extension Methods（C# 3.0，2007 年）：C# 是最早系统引入扩展方法的主流静态类型语言。C# 通过 this 修饰符标记静态方法的第一个参数，使其可以像实例方法一样调用。Kotlin 借鉴了这一语法形态，但采用了更简洁的 fun ReceiverType.name() 语法。

2. Groovy 的 Categories 与 ExpandoMetaClass（Groovy 1.0，2007 年）：Groovy 通过元编程（Metaprogramming）实现运行时方法注入，但代价是性能损失与动态类型风险。Kotlin 选择在编译期完成扩展解析，保留静态类型安全性。

3. Scala 的 Implicit Conversion（Scala 2.0，2008 年）：Scala 的 implicit class 可以实现类似扩展函数的效果，但其解析规则复杂、易产生歧义。Kotlin 简化了这一机制，要求显式 import 扩展函数。

Kotlin 1.0 的扩展函数语法如下：

// Kotlin 1.0
fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1]
    this[index1] = this[index2]
    this[index2] = tmp
}

此时的扩展函数已经具备了核心语义：静态分发、接收者参数、与成员函数优先级规则。

2.3 Kotlin 1.1（2017 年 5 月）：扩展属性与内联扩展

Kotlin 1.1 引入了两项重要改进：

1. 扩展属性（Extension Properties）：允许为已有类添加计算属性，但不能有 backing field。
2. 内联扩展函数（Inline Extension Functions）：通过 inline 关键字标记扩展函数，编译器在调用处展开函数体，消除方法调用开销。

// 扩展属性（Kotlin 1.1+）
val String.lastChar: Char
    get() = this[length - 1]

// 内联扩展函数
inline fun <T> List<T>.filterIndexed(predicate: (Int, T) -> Boolean): List<T> {
    // ...
}

2.4 Kotlin 1.4（2020 年 8 月）：内联类与扩展函数协同

Kotlin 1.4 将内联类（Inline Class）提升为 Beta 状态，并在 1.5 中稳定化。内联类与扩展函数协同后，实现了”零开销抽象”（Zero-cost Abstraction）：

@JvmInline
value class Meter(val value: Double)

// 扩展函数直接作用于内联类
fun Meter.toKilometer(): Double = value / 1000.0

2.5 Kotlin 1.5（2021 年 5 月）：value class 稳定化

Kotlin 1.5 将 inline class 重命名为 value class，并要求 JVM 平台必须加 @JvmInline 注解。这一改动使得扩展函数的接收者可以是值类型，进一步丰富了扩展函数的应用场景。

2.6 Kotlin 1.6 与 1.7（2021-2022 年）：K2 编译器预览

Kotlin 1.6 引入了 K2 编译器的前端预览版（Frontend Preview），Kotlin 1.7 进一步完善了 K2 的诊断能力。K2 编译器采用全新的架构：

• 统一前端：将 Kotlin/JVM、Kotlin/JS、Kotlin/Native 共用同一套语法分析与类型检查逻辑。
• 基于 IR 的后端：所有目标平台都通过 Intermediate Representation（IR）生成最终代码，便于跨平台优化。
• 性能提升：K2 在大型项目上的编译速度提升约 2 倍。

K2 对扩展函数的影响主要体现在：

• 更严格的 @SinceKotlin 检查，避免误用过新的 API。
• 更精确的扩展函数解析优先级诊断，减少与成员函数冲突时的困惑。
• IR 阶段支持更激进的扩展函数内联优化。

2.7 Kotlin 1.9（2023 年 7 月）：K2 Beta

Kotlin 1.9 将 K2 编译器标记为 Beta，并默认开启 K2 的部分优化。此时扩展函数的解析已经完全基于 K2 前端，性能与诊断质量均有显著提升。

2.8 Kotlin 2.0（2024 年 5 月）：K2 编译器 GA

Kotlin 2.0 于 2024 年 5 月正式发布，K2 编译器进入稳定状态（Stable，GA）。K2 对扩展函数的影响包括：

1. 更快的解析速度：扩展函数的重载解析（Overload Resolution）在 K2 中速度提升约 2-3 倍。
2. 更智能的诊断：当扩展函数与成员函数冲突时，K2 能提供更详细的修复建议。
3. IR 优化：K2 的 IR 后端能更好地内联扩展函数，减少虚调用。
4. 跨平台一致性：K2 保证了扩展函数在 JVM、JS、Native、Wasm 上的行为完全一致。

2.9 JetBrains 的设计哲学

JetBrains 在设计扩展函数时遵循了以下哲学：

1. 静态优先：所有扩展函数在编译期静态解析，避免运行时元编程开销。这牺牲了动态扩展能力，但保证了类型安全与性能。

2. 显式优于隐式：扩展函数必须显式 import（或处于同一包内），避免 C# 那样的全局命名空间污染。

3. 最小惊讶原则：扩展函数的可见性、优先级、分发规则必须简单直观，避免开发者产生意外。

4. 互操作优先：扩展函数编译为标准的 JVM 静态方法，与 Java 完全互操作，Java 可以直接调用 ClassName.funcName(receiver)。

5. 渐进式增强：扩展函数不是替代成员函数的方案，而是补充。JetBrains 鼓励库作者在无法修改源码时使用扩展函数，而非反射或继承。

2.10 时间线总览

2010  Kotlin 项目启动
2011  Kotlin 首次公开（JetBrains 宣布）
2016  Kotlin 1.0 GA — 扩展函数首发
2017  Kotlin 1.1 — 扩展属性、内联扩展
2017  Google 宣布 Kotlin 为 Android 一级语言
2018  Kotlin 1.3 — 协程 GA，扩展函数支持 suspend
2020  Kotlin 1.4 — 内联类 Beta，与扩展函数协同
2021  Kotlin 1.5 — value class GA
2022  Kotlin 1.7 — K2 预览
2023  Kotlin 1.9 — K2 Beta
2024  Kotlin 2.0 — K2 GA，扩展函数性能大幅提升

3. 形式化定义

3.1 Kotlin 语言规范（Kotlin Language Specification）

根据 Kotlin 官方语言规范（kotlinlang.org/spec），扩展函数的形式化语法定义如下：

其中：

• $\text{modifiers?}$：可选的修饰符，如 public、private、internal、inline、suspend、tailrec、operator、infix。
• $\text{TypeParameters?}$：可选的类型参数，如 <T, R>。
• $\text{ReceiverType}$：接收者类型，可以是类、接口、可空类型、泛型类型。
• $\text{FunctionName}$：函数名，遵循 Kotlin 标识符命名规则。
• $\text{FunctionValueParameters}$：参数列表，可为空。
• $\text{FunctionReturnType?}$：可选的返回类型。
• $\text{FunctionBody?}$：可选的函数体，可以是表达式或代码块。

3.2 接收者类型的约束

扩展函数的接收者类型 $\text{ReceiverType}$ 必须满足以下约束：

1. 必须是具体类型或类型参数：不能是 Nothing，不能是动态类型（dynamic，Kotlin/JS 除外）。
2. 可空类型允许：String? 是合法的接收者类型，此时 this 可能为 null。
3. 泛型类型允许：List<T> 是合法的接收者类型，但受类型擦除限制，运行时无法判断具体类型。
4. 函数类型允许：(Int) -> String 是合法的接收者类型，便于对函数式值进行扩展。

3.3 扩展函数的语义（Semantics）

根据 Kotlin 语言规范，扩展函数的语义可形式化定义为：

对于扩展函数 fun T.f(args): R，其调用 x.f(args)（其中 x 的静态类型为 T）等价于：

即：扩展函数调用在语义上等价于以接收者为第一个参数的普通函数调用。这一等价关系保证了扩展函数的静态分发特性。

3.4 JVM 字节码规范

在 JVM 平台上，扩展函数编译为位于文件类（File Class）中的静态方法。其字节码结构遵循 JVM 规范（Java Virtual Machine Specification, JVMS）的第 4 章与第 5 章。

静态方法签名：

修饰符: public static final
返回类型: 扩展函数声明的返回类型
方法名: 扩展函数名
参数列表: [ReceiverType, Arg1, Arg2, ..., ArgN]
异常表: 可选

Kotlin 元数据注解：

• @kotlin.Metadata：标记该类是 Kotlin 编译产物，包含 Kotlin-specific 元信息。
• @SinceKotlin：标记该扩展函数自哪个 Kotlin 版本引入。
• @JvmName：指定编译后的 JVM 方法名，用于解决平台命名冲突。

3.5 解析优先级规则

Kotlin 规范明确定义了扩展函数与成员函数的解析优先级：

即：当接收者类型上存在同名同签名的成员函数与扩展函数时，成员函数始终优先。这一规则不可被覆盖、不可被 @JvmName 影响。

进一步，对于多个扩展函数之间的重载解析（Overload Resolution），Kotlin 遵循以下顺序：

1. 接收者类型最具体优先：Dog 上的扩展优先于 Animal 上的扩展（假设 Dog <: Animal）。
2. 类型参数已实例化优先：List<Int> 上的扩展优先于 List<T> 上的扩展。
3. 导入顺序不影响：扩展函数的解析不依赖 import 顺序，避免歧义。
4. 歧义时报错：若多个扩展函数同等具体，编译器报错 Overload resolution ambiguity。

3.6 形式化的接收者绑定

设扩展函数 $f$ 定义在类型 $T$ 上：$f : T \times A_1 \times \cdots \times A_n \to R$。

对于表达式 $e.f(a_1, \ldots, a_n)$，其中 $e : T$：

注意：类型检查基于 $e$ 的静态类型，而非运行时类型。这是扩展函数静态分发的形式化根源。

4. 理论推导与原理解析

4.1 编译期转换（Compilation Transformation）

考虑以下 Kotlin 扩展函数：

package com.example.extensions

fun String.addExclamation(): String = this + "!"

编译器将其转换为如下的 Java 等价代码：

package com.example.extensions;

public final class StringKt {
    public static final String addExclamation(String receiver) {
        return receiver + "!";
    }
}

转换过程的代数表示：

文件类名（File Class Name）的生成规则：

• 若源文件名为 String.kt，则类名为 StringKt。
• 可通过 @file:JvmName("StringUtils") 注解自定义类名。
• 可通过 @file:JvmMultifileClass 注解使多个源文件合并为同一个类。

4.2 接收者参数的传递

接收者 this 在扩展函数内部作为方法的第一个参数传入。考虑：

fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1]
    this[index1] = this[index2]
    this[index2] = tmp
}

编译为字节码后的伪代码：

public static final void swap(MutableList<Integer> receiver, int index1, int index2) {
    int tmp = receiver.get(index1);
    receiver.set(index1, receiver.get(index2));
    receiver.set(index2, tmp);
}

数学上，扩展函数的接收者绑定可以表示为：

4.3 静态分发原理

扩展函数的核心特性是静态分发。考虑以下继承结构：

open class Animal
class Dog : Animal()
class Cat : Animal()

fun Animal.sound() = "Generic animal sound"
fun Dog.sound() = "Woof"
fun Cat.sound() = "Meow"

fun main() {
    val animal: Animal = Dog()
    println(animal.sound())  // 输出 "Generic animal sound"
}

输出的解释：animal.sound() 的解析基于 animal 的静态类型 Animal，而非运行时类型 Dog。因此编译器选择 Animal.sound() 扩展函数。

形式化地，分发规则为：

而非：

这一差异是扩展函数与成员函数（虚方法）的核心区别。成员函数使用虚方法分发（Virtual Dispatch），基于运行时类型。

4.4 与成员函数优先级的形式化证明

命题：当接收者类型 $T$ 上同时存在成员函数 $f_{\text{member}}$ 与扩展函数 $f_{\text{ext}}$，且签名相同时，调用 $e.f()$ 总是解析为 $f_{\text{member}}$。

证明：

1. Kotlin 编译器在解析 e.f() 时，首先在 $T$ 的成员函数表中查找名为 f 且签名匹配的成员。
2. 若找到，则立即选定该成员函数，不进入扩展函数查找阶段。
3. 仅当成员函数表中没有匹配项时，编译器才进入扩展函数查找阶段。
4. 扩展函数查找基于导入的扩展函数与同包扩展函数。

因此，成员函数优先级严格高于扩展函数。$\blacksquare$

4.5 Nullable 接收者

扩展函数允许接收者为 null，这是与成员函数的关键区别（成员函数调用 null.foo() 抛出 NullPointerException）。

fun String?.isNullOrBlank(): Boolean {
    return this == null || this.isBlank()
}

字节码等价：

public static final boolean isNullOrBlank(String receiver) {
    return receiver == null || receiver.isBlank();
}

数学上，nullable 接收者的扩展函数 $f : T? \times A \to R$ 接受 null 作为合法输入：

4.6 泛型扩展函数与类型擦除

考虑泛型扩展函数：

fun <T> List<T>.second(): T = this[1]

由于 JVM 的类型擦除（Type Erasure），编译后的字节码为：

public static final <T> T second(List<? extends T> receiver) {
    return receiver.get(1);
}

在字节码层面，泛型类型 T 被擦除为 Object（或上界）。这意味着运行时无法通过反射判断 List<Int>.second() 与 List<String>.second() 的区别。

形式化地，类型擦除可以表示为：

4.7 扩展函数与内联

当扩展函数被标记为 inline 时，编译器在调用处展开函数体，消除方法调用开销。

inline fun <T, R> List<T>.map(transform: (T) -> R): List<R> {
    val result = ArrayList<R>(size)
    for (item in this) {
        result.add(transform(item))
    }
    return result
}

内联展开后的伪代码：

// 调用 list.map { it * 2 }
val result = ArrayList<Int>(list.size)
for (item in list) {
    result.add(item * 2)  // transform 被内联展开
}

形式化地，内联展开可以表示为：

4.8 扩展属性的形式化

扩展属性本质上是一对扩展函数（getter + setter）的语法糖：

val String.lastChar: Char
    get() = this[length - 1]

等价于：

fun String.getLastChar(): Char = this[length - 1]

// 调用 "abc".lastChar 实际上是 getLastChar()

形式化定义：

约束：

• 没有 backing field，因此不能初始化。
• 不能存储状态，所有计算必须基于接收者。
• var 扩展属性必须有 setter，setter 同样不能有 backing field。

4.9 K2 编译器的 IR 阶段优化

Kotlin 2.0 的 K2 编译器在 IR（Intermediate Representation）阶段对扩展函数进行以下优化：

1. 死代码消除：未被引用的扩展函数从字节码中移除。
2. 内联展开：inline 扩展函数在 IR 阶段被展开，消除方法调用。
3. 接收者消除：当扩展函数不使用 this 时，编译器移除接收者参数。
4. 桥接方法消除：K2 减少桥接方法的生成，减小字节码体积。

数学上，K2 的 IR 优化可以建模为一系列重写规则：

4.10 二进制兼容性

扩展函数的二进制兼容性是库设计中需要特别关注的问题。考虑：

• 库 v1.0 定义了 fun String.foo(): Int，调用方编译后字节码中包含 INVOKESTATIC StringKt.foo(String)I。
• 库 v1.1 移除了该扩展函数，调用方在运行时将抛出 NoSuchMethodError。

形式化地，扩展函数的二进制兼容性要求：

即：新版本必须保留旧版本的所有公共 API（包括扩展函数）。

5. 代码示例

5.1 基础示例：String 扩展

package com.example.stringext

/**
 * 字符串扩展函数集合
 * @since 1.0
 */
object StringExtensions

/**
 * 将字符串首字母大写
 * @receiver 输入字符串
 * @return 首字母大写后的字符串，若输入为空则原样返回
 */
fun String.capitalizeFirst(): String {
    if (isEmpty()) return this
    return this[0].uppercaseChar() + substring(1)
}

/**
 * 反转字符串
 */
fun String.reverse(): String = reversed()

/**
 * 检查是否为回文
 */
fun String.isPalindrome(): Boolean = this == reversed()

/**
 * 扩展属性：最后一个字符
 */
val String.lastChar: Char
    get() = this[length - 1]

fun main() {
    println("hello".capitalizeFirst())  // "Hello"
    println("abc".reverse())             // "cba"
    println("aba".isPalindrome())        // true
    println("kotlin".lastChar)           // 'n'
}

5.2 通用 swap 扩展

package com.example.collectionext

/**
 * 交换 MutableList 中两个位置的元素
 * @param index1 第一个位置
 * @param index2 第二个位置
 * @throws IndexOutOfBoundsException 若索引越界
 */
fun <T> MutableList<T>.swap(index1: Int, index2: Int) {
    val tmp = this[index1]
    this[index1] = this[index2]
    this[index2] = tmp
}

fun main() {
    val list = mutableListOf(1, 2, 3, 4)
    list.swap(0, 3)
    println(list)  // [4, 2, 3, 1]
}

5.3 Nullable 接收者

package com.example.nullext

/**
 * 安全地获取字符串长度，null 返回 0
 */
fun String?.lengthOrZero(): Int = this?.length ?: 0

/**
 * 安全地 trim，null 返回空字符串
 */
fun String?.trimOrEmpty(): String = this?.trim() ?: ""

fun main() {
    val s: String? = null
    println(s.lengthOrZero())  // 0
    println(s.trimOrEmpty())    // ""

    val s2: String? = "  hello  "
    println(s2.lengthOrZero())  // 9
    println(s2.trimOrEmpty())   // "hello"
}

5.4 扩展属性

package com.example.propext

val String.firstChar: Char
    get() = if (isEmpty()) throw NoSuchElementException("Empty string") else this[0]

val List<Int>.sumOrNull: Int?
    get() = if (isEmpty()) null else sum()

var MutableList<Int>.firstOrSet: Int
    get() = if (isEmpty()) throw NoSuchElementException() else this[0]
    set(value) {
        if (isEmpty()) add(value) else this[0] = value
    }

fun main() {
    println("kotlin".firstChar)  // 'k'
    println(listOf(1, 2, 3).sumOrNull)  // 6
    println(emptyList<Int>().sumOrNull)  // null

    val list = mutableListOf(10, 20)
    list.firstOrSet = 100
    println(list)  // [100, 20]
}

5.5 DSL 构建器（生产级示例）

package com.example.dsl

/**
 * HTML DSL 构建器，演示扩展函数在 DSL 中的应用
 */

@DslMarker
annotation class HtmlDsl

@HtmlDsl
class Tag(val name: String) {
    private val children = mutableListOf<Tag>()
    private val attributes = mutableMapOf<String, String>()

    fun attr(name: String, value: String) {
        attributes[name] = value
    }

    operator fun String.invoke(block: Tag.() -> Unit) {
        val child = Tag(this)
        child.block()
        children.add(child)
    }

    operator fun String.invoke(value: String) {
        attributes[this] = value
    }

    override fun toString(): String {
        val attrs = if (attributes.isEmpty()) "" else " " + attributes.entries
            .joinToString(" ") { "${it.key}=\"${it.value}\"" }
        val body = if (children.isEmpty()) "" else children.joinToString("") { it.toString() }
        return "<$name$attrs>$body</$name>"
    }
}

fun html(block: Tag.() -> Unit): String {
    val tag = Tag("html")
    tag.block()
    return tag.toString()
}

fun main() {
    val result = html {
        "head" {
            "title" {
                // 子节点
                "Hello" // 这里需要扩展
            }
        }
        "body" {
            "h1"("class" to "header")
        }
    }
    println(result)
}

5.6 @JvmName 解决命名冲突

package com.example.jvmname

/**
 * 不同类型上的同名扩展函数，使用 @JvmName 区分字节码方法名
 */

@JvmName("isBlankString")
fun CharSequence?.isBlankSafe(): Boolean = this?.isBlank() ?: true

@JvmName("isBlankList")
fun <T> List<T>?.isBlankSafe(): Boolean = this?.isEmpty() ?: true

@JvmName("isBlankMap")
fun <K, V> Map<K, V>?.isBlankSafe(): Boolean = this?.isEmpty() ?: true

5.7 企业级 Gradle 配置

// build.gradle.kts
plugins {
    kotlin("jvm") version "2.0.0"
    `maven-publish`
    id("org.jetbrains.dokka") version "1.9.20"
}

group = "com.example"
version = "1.0.0"

repositories {
    mavenCentral()
}

dependencies {
    implementation(kotlin("stdlib"))
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")
    testImplementation(kotlin("test"))
    testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
}

tasks.test {
    useJUnitPlatform()
}

kotlin {
    jvmToolchain(17)
}

tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
    kotlinOptions {
        freeCompilerArgs = listOf(
            "-Xjsr305=strict",
            "-Xcontext-receivers",
            "-Xcontext-parameters",
            "-opt-in=kotlin.RequiresOptIn"
        )
        jvmTarget = "17"
    }
}

// 发布配置
publishing {
    publications {
        create<MavenPublication>("maven") {
            from(components["kotlin"])
            artifact(tasks["kotlinSourcesJar"])
            artifact(tasks["javadocJar"])
            pom {
                name.set("FANDEX Kotlin Extensions")
                description.set("Production-grade Kotlin extension functions")
                url.set("https://github.com/fandex/kotlin-ext")
                licenses {
                    license {
                        name.set("Apache-2.0")
                        url.set("https://www.apache.org/licenses/LICENSE-2.0")
                    }
                }
            }
        }
    }
}

5.8 内联扩展函数

package com.example.inlineext

/**
 * 内联扩展函数，消除方法调用开销
 */

inline fun <T> List<T>.firstOr(default: T): T =
    if (isEmpty()) default else this[0]

inline fun <T, R> List<T>.map(transform: (T) -> R): List<R> {
    val result = ArrayList<R>(size)
    for (item in this) {
        result.add(transform(item))
    }
    return result
}

inline fun <T> List<T>.filter(predicate: (T) -> Boolean): List<T> {
    val result = ArrayList<T>(size)
    for (item in this) {
        if (predicate(item)) {
            result.add(item)
        }
    }
    return result
}

inline fun <T, R> T.let(block: (T) -> R): R = block(this)

inline fun <T> T.apply(block: T.() -> Unit): T {
    block()
    return this
}

fun main() {
    val list = listOf(1, 2, 3, 4, 5)
    val doubled = list.map { it * 2 }
    println(doubled)  // [2, 4, 6, 8, 10]
}

5.9 协程扩展函数

package com.example.coroutinesext

import kotlinx.coroutines.*

/**
 * 为协程上下文添加扩展函数，简化协程启动
 */
fun CoroutineScope.launchIO(block: suspend CoroutineScope.() -> Unit): Job =
    launch(Dispatchers.IO, block = block)

fun CoroutineScope.launchDefault(block: suspend CoroutineScope.() -> Unit): Job =
    launch(Dispatchers.Default, block = block)

fun CoroutineScope.launchMain(block: suspend CoroutineScope.() -> Unit): Job =
    launch(Dispatchers.Main, block = block)

/**
 * 为 Deferred 添加超时扩展
 */
suspend fun <T> Deferred<T>.awaitWithTimeout(timeoutMs: Long): T =
    withTimeout(timeoutMs) { await() }

fun main() = runBlocking {
    val result = launchIO {
        delay(100)
        println("IO task done")
    }
    result.join()
}

5.10 测试扩展函数

package com.example.testext

import org.junit.jupiter.api.Assertions
import kotlin.test.Test

/**
 * 测试断言扩展函数
 */
fun <T> T.assertEquals(expected: T) {
    Assertions.assertEquals(expected, this)
}

fun <T> T?.assertNotNull() {
    Assertions.assertNotNull(this)
}

fun <T : Any> T?.assertNull() {
    Assertions.assertNull(this)
}

fun <T : Throwable> assertThrows(block: () -> Unit): T {
    return Assertions.assertThrows(T::class.java, block)
}

class TestExtensionsTest {
    @Test
    fun `test string extension`() {
        "hello".assertEquals("hello")
        "hello".length.assertEquals(5)
    }

    @Test
    fun `test null assertions`() {
        val s: String? = null
        s.assertNull()

        val s2: String? = "value"
        s2.assertNotNull()
    }
}

5.11 Context Receiver 扩展（实验性）

package com.example.contextext

// Kotlin 2.0+ 的 context 参数（原 context receiver）
context(logger: Logger)
fun String.logInfo() {
    logger.info(this)
}

context(logger: Logger)
fun String.logError() {
    logger.error(this)
}

class Logger {
    fun info(msg: String) = println("INFO: $msg")
    fun error(msg: String) = println("ERROR: $msg")
}

fun main() {
    with(Logger()) {
        "Hello".logInfo()
        "World".logError()
    }
}

5.12 sealed 类扩展

package com.example.sealedext

sealed class Result<out T> {
    data class Success<T>(val value: T) : Result<T>()
    data class Failure(val error: Throwable) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

/**
 * 为 sealed Result 添加扩展函数，使用 when 表达式保证穷尽性
 */
fun <T> Result<T>.getOrElse(default: T): T = when (this) {
    is Result.Success -> value
    is Result.Failure -> default
    Result.Loading -> default
}

fun <T> Result<T>.isSuccess(): Boolean = this is Result.Success

fun <T> Result<T>.isFailure(): Boolean = this is Result.Failure

fun <T, R> Result<T>.map(transform: (T) -> R): Result<R> = when (this) {
    is Result.Success -> Result.Success(transform(value))
    is Result.Failure -> this
    Result.Loading -> Result.Loading
}

fun main() {
    val result: Result<Int> = Result.Success(42)
    println(result.getOrElse(0))  // 42
    println(result.map { it * 2 })  // Success(84)
}

5.13 Kotlin/Native 平台扩展

package com.example.nativeext

// commonMain
expect fun String.nativeHash(): Int

// jvmMain
actual fun String.nativeHash(): Int = hashCode()

// nativeMain
actual fun String.nativeHash(): Int {
    var hash = 0
    for (c in this) {
        hash = hash * 31 + c.code
    }
    return hash
}

// jsMain
actual fun String.nativeHash(): Int {
    var hash = 0
    for (i in 0 until length) {
        hash = ((hash shl 5) - hash + this[i].code) | 0
    }
    return hash
}

5.14 反射与扩展函数

package com.example.reflectext

import kotlin.reflect.full.memberExtensionFunctions
import kotlin.reflect.full.memberFunctions

class Container {
    fun String.shout(): String = this.uppercase()
}

fun main() {
    val kClass = Container::class
    println("Member functions:")
    kClass.memberFunctions.forEach { println("  ${it.name}") }
    println("Extension functions:")
    kClass.memberExtensionFunctions.forEach { println("  ${it.name}") }
}

5.15 完整生产级示例：日志扩展

package com.example.loggingext

import org.slf4j.Logger
import org.slf4j.LoggerFactory

/**
 * 生产级日志扩展，提供结构化日志能力
 */

inline fun <reified T> T.logger(): Logger = LoggerFactory.getLogger(T::class.java)

inline fun Logger.debugExt(message: () -> String) {
    if (isDebugEnabled) debug(message())
}

inline fun Logger.infoExt(message: () -> String) {
    if (isInfoEnabled) info(message())
}

inline fun Logger.errorExt(throwable: Throwable? = null, message: () -> String) {
    if (isErrorEnabled) {
        if (throwable != null) error(message(), throwable)
        else error(message())
    }
}

class UserService {
    private val log = logger()

    fun findUser(id: String): String? {
        log.debugExt { "Finding user with id=$id" }
        return try {
            "user_$id"
        } catch (e: Exception) {
            log.errorExt(e) { "Failed to find user id=$id" }
            null
        }
    }
}

fun main() {
    val service = UserService()
    println(service.findUser("42"))
}

6. 对比分析

6.1 与 Java 的对比

Java 原生不支持扩展函数，需通过以下方式模拟：

// Java 模拟扩展函数
public class StringUtils {
    public static String capitalizeFirst(String s) {
        if (s.isEmpty()) return s;
        return Character.toUpperCase(s.charAt(0)) + s.substring(1);
    }
}

// 调用
String result = StringUtils.capitalizeFirst("hello");

6.2 与 C# 的对比

// C# 扩展方法
public static class StringExtensions
{
    public static string CapitalizeFirst(this string s)
    {
        if (string.IsNullOrEmpty(s)) return s;
        return char.ToUpper(s[0]) + s.Substring(1);
    }
}

// 调用
string result = "hello".CapitalizeFirst();

6.3 与 Scala 的对比

// Scala implicit class
object StringExtensions {
  implicit class StringOps(val s: String) extends AnyVal {
    def capitalizeFirst: String =
      if (s.isEmpty) s
      else s.head.toUpper + s.tail
  }
}

// 调用
import StringExtensions._
"hello".capitalizeFirst

6.4 与 Swift 的对比

// Swift extension
extension String {
    func capitalizeFirst() -> String {
        guard let first = first else { return self }
        return String(first).uppercased() + dropFirst()
    }
}

// 调用
"hello".capitalizeFirst()

6.5 与 Rust 的对比

// Rust trait
trait CapitalizeFirst {
    fn capitalize_first(&self) -> String;
}

impl CapitalizeFirst for str {
    fn capitalize_first(&self) -> String {
        if self.is_empty() {
            return String::new();
        }
        let mut chars = self.chars();
        match chars.next() {
            None => String::new(),
            Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
        }
    }
}

// 调用
"hello".capitalize_first();

6.6 跨语言对比总表

7. 常见陷阱与最佳实践

7.1 陷阱一：静态分发误解

错误代码：

open class Animal
class Dog : Animal()
class Cat : Animal()

fun Animal.sound() = "generic"
fun Dog.sound() = "woof"

fun main() {
    val animals: List<Animal> = listOf(Dog(), Cat(), Animal())
    animals.forEach { println(it.sound()) }
    // 期望输出：woof, meow, generic
    // 实际输出：generic, generic, generic
}

问题分析：扩展函数静态分发，基于声明类型 Animal，而非运行时类型。

解决方案：使用成员函数实现多态。

open class Animal {
    open fun sound() = "generic"
}
class Dog : Animal() {
    override fun sound() = "woof"
}
class Cat : Animal() {
    override fun sound() = "meow"
}

fun main() {
    val animals: List<Animal> = listOf(Dog(), Cat(), Animal())
    animals.forEach { println(it.sound()) }
    // 输出：woof, meow, generic
}

7.2 陷阱二：与成员函数冲突

错误代码：

class Foo {
    fun bar() = "member"
}

fun Foo.bar() = "extension"

fun main() {
    println(Foo().bar())  // 输出 "member"，扩展函数被覆盖
}

问题分析：成员函数始终优先于扩展函数。

最佳实践：避免为第三方库的类添加与未来可能新增的成员函数同名的扩展函数，以免被静默覆盖。使用 @Deprecated 或命名约定区分。

7.3 陷阱三：扩展函数与空安全

错误代码：

fun String.removeVowels(): String {
    val vowels = setOf('a', 'e', 'i', 'o', 'u')
    return filter { it.lowercaseChar() !in vowels }
}

fun main() {
    val s: String? = null
    println(s.removeVowels())  // NullPointerException
}

问题分析：String 是非空接收者，调用 null.removeVowels() 会抛 NPE。

解决方案：明确区分 nullable 与 non-nullable 接收者。

// nullable 版本
fun String?.removeVowelsOrNull(): String? = this?.filter {
    it.lowercaseChar() !in setOf('a', 'e', 'i', 'o', 'u')
}

// 非空版本（保持原样）
fun String.removeVowels(): String = filter {
    it.lowercaseChar() !in setOf('a', 'e', 'i', 'o', 'u')
}

7.4 陷阱四：扩展函数中的并发安全

错误代码：

var counter = 0

fun Int.incrementCounter(): Int {
    counter += this  // 非线程安全
    return counter
}

问题分析：扩展函数访问全局可变状态，存在数据竞争。

解决方案：使用 AtomicInteger 或 Mutex。

import java.util.concurrent.atomic.AtomicInteger

val counter = AtomicInteger(0)

fun Int.incrementCounter(): Int {
    return counter.addAndGet(this)
}

7.5 陷阱五：扩展属性不能存储状态

错误代码：

val String.cachedLength: Int
    get() {
        // 错误：不能有 backing field
        // var cached: Int = 0  // 编译错误
        return length
    }

问题分析：扩展属性不能有 backing field，因此无法缓存。

解决方案：使用外部 Map 存储。

private val lengthCache = mutableMapOf<String, Int>()

val String.cachedLength: Int
    get() = lengthCache.getOrPut(this) { length }

注意：此方案有线程安全问题，生产环境应使用 ConcurrentHashMap。

7.6 陷阱六：扩展函数命名冲突

错误代码：

// File: a.kt
package com.example.a
fun String.foo() = "a"

// File: b.kt
package com.example.b
fun String.foo() = "b"

// 调用方
import com.example.a.foo
import com.example.b.foo  // 歧义

fun main() {
    "x".foo()  // 编译错误：Overload resolution ambiguity
}

解决方案：使用 as 重命名导入。

import com.example.a.foo as fooA
import com.example.b.foo as fooB

fun main() {
    println("x".fooA())  // "a"
    println("x".fooB())  // "b"
}

7.7 陷阱七：扩展函数与反射

问题：通过反射调用扩展函数需要传入接收者作为第一个参数。

fun String.greet(): String = "Hello, $this!"

fun main() {
    val function = ::greet
    println(function.call("World"))  // "Hello, World!"
    // 反射调用时，"World" 作为接收者传入
}

7.8 陷阱八：扩展函数与二进制兼容性

问题：库 v1.0 提供了 fun String.foo()，库 v2.0 移除该扩展函数，调用方运行时报 NoSuchMethodError。

最佳实践：使用 @Deprecated 注解渐进式废弃。

@Deprecated(
    "Use String.bar() instead",
    ReplaceWith("bar()"),
    level = DeprecationLevel.WARNING
)
fun String.foo(): String = "foo"

fun String.bar(): String = "bar"

7.9 陷阱九：扩展函数与协程泄漏

错误代码：

fun CoroutineScope.launchLongTask(): Job = launch {
    while (isActive) {
        delay(1000)
        // 长时间运行的任务
    }
}

fun main() {
    val scope = CoroutineScope(Dispatchers.Default)
    scope.launchLongTask()
    // scope 未取消，任务泄漏
}

解决方案：明确生命周期管理。

fun CoroutineScope.launchLongTask(): Job = launch {
    try {
        while (isActive) {
            delay(1000)
        }
    } finally {
        // 清理资源
    }
}

fun main() = runBlocking {
    val scope = CoroutineScope(Dispatchers.Default)
    val job = scope.launchLongTask()
    delay(5000)
    job.cancelAndJoin()
    scope.cancel()
}

7.10 陷阱十：扩展函数与可空泛型

问题：

fun <T> T.identity(): T = this

fun main() {
    val x: String? = null
    println(x.identity())  // 输出 null，但类型为 String?
}

分析：泛型类型参数 T 在 JVM 上会被擦除，可空性信息丢失。需要显式约束。

7.11 最佳实践总结

1. 优先使用成员函数：当能修改源码时，使用成员函数而非扩展函数。
2. 使用包级扩展：将扩展函数按接收者类型分文件组织，避免命名冲突。
3. 使用 @JvmName：在跨 JVM 互操作时，使用 @JvmName 解决重载冲突。
4. 避免过长链式调用：扩展函数链式调用过多时，可读性下降。
5. 谨慎使用 nullable 接收者：明确语义，避免误用。
6. 使用 inline 优化热点代码：对高频调用的扩展函数使用 inline。
7. 文档化扩展函数：明确说明接收者语义、返回值、副作用。
8. 考虑二进制兼容性：库设计中谨慎添加/移除扩展函数。

8. 工程实践

8.1 构建配置

// build.gradle.kts
plugins {
    kotlin("jvm") version "2.0.0"
    id("org.jetbrains.kotlinx.binary-compatibility-validator") version "0.14.0"
}

kotlin {
    explicitApi()
    // 或 explicitApiWarning()
}

// binary-compatibility-validator 自动生成 API 表面
apiValidation {
    ignoredPackages.add("com.example.internal")
}

8.2 性能基准测试

package com.example.benchmark

import org.openjdk.jmh.annotations.*
import java.util.concurrent.TimeUnit

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
open class ExtensionBenchmark {

    @Benchmark
    fun benchmarkExtension(): String {
        return "hello world".capitalizeFirst()
    }

    @Benchmark
    fun benchmarkStaticMethod(): String {
        return StringUtils.capitalizeFirst("hello world")
    }

    @Benchmark
    fun benchmarkInlineExtension(): Int {
        return listOf(1, 2, 3, 4, 5).firstOr(0)
    }
}

8.3 调试扩展函数

// 在 IntelliJ IDEA 中调试扩展函数：
// 1. 在扩展函数体内打断点
// 2. 调试器会显示接收者 this 的值
// 3. 使用 Evaluate Expression 查看表达式

fun String.debug(): String {
    println("Receiver: $this")  // 可观察接收者
    return this
}

8.4 Kotlin/Native 中的扩展函数

// Kotlin/Native 中扩展函数的内存模型
// - 不存在装箱（与 JVM 不同）
// - 内联类直接编译为值类型
// - 扩展函数调用与静态方法等价

// commonMain
expect fun Double.formatCurrency(currency: String): String

// iosMain
actual fun Double.formatCurrency(currency: String): String {
    val formatter = NSNumberFormatter()
    formatter.numberStyle = NSNumberFormatterCurrencyStyle
    formatter.currencyCode = currency
    return formatter.stringFromNumber(this) ?: ""
}

8.5 KMP（Kotlin Multiplatform）中的扩展函数

// commonMain
expect fun String.normalize(): String

// jvmMain
actual fun String.normalize(): String = java.text.Normalizer.normalize(this, java.text.Normalizer.Form.NFC)

// jsMain
actual fun String.normalize(): String = asDynamic().normalize("NFC") as String

// nativeMain
actual fun String.normalize(): String {
    // 实现自己的 normalize 逻辑
    return this
}

8.6 代码生成与注解处理

// 使用 KSP（Kotlin Symbol Processing）生成扩展函数
@Target(AnnotationTarget.CLASS)
annotation class GenerateExtensions

@GenerateExtensions
data class User(val name: String, val age: Int)

// KSP 处理器生成：
// fun User.greet(): String = "Hello, $name"
// fun User.isAdult(): Boolean = age >= 18

8.7 Gradle 构建优化

// 启用 Kotlin 编译器优化
kotlin {
    compilerOptions {
        freeCompilerArgs.add("-Xinline-classes")
        freeCompilerArgs.add("-Xcontext-receivers")
        allWarningsAsErrors = true
    }
}

// 增量编译
tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
    kotlinOptions.incremental = true
}

8.8 测试策略

package com.example.test

import kotlin.test.Test
import kotlin.test.assertEquals

class StringExtensionsTest {
    @Test
    fun `capitalizeFirst should capitalize first letter`() {
        // Given
        val input = "hello"
        // When
        val result = input.capitalizeFirst()
        // Then
        assertEquals("Hello", result)
    }

    @Test
    fun `capitalizeFirst should return empty for empty string`() {
        assertEquals("", "".capitalizeFirst())
    }

    @Test
    fun `isPalindrome should return true for palindromes`() {
        assertTrue("aba".isPalindrome())
        assertTrue("racecar".isPalindrome())
    }

    @Test
    fun `isPalindrome should return false for non-palindromes`() {
        assertFalse("hello".isPalindrome())
    }
}

9. 案例研究

9.1 案例一：Android View 扩展

package com.example.androidext

import android.view.View
import android.widget.TextView
import androidx.annotation.IdRes

/**
 * 视图可见性扩展
 */
fun View.visible() { visibility = View.VISIBLE }
fun View.gone() { visibility = View.GONE }
fun View.invisible() { visibility = View.INVISIBLE }

fun View.toggleVisibility() {
    visibility = if (visibility == View.VISIBLE) View.GONE else View.VISIBLE
}

/**
 * 防抖点击
 */
var View.lastClickTime: Long
    get() = (getTag(R.id.tag_last_click_time) as? Long) ?: 0L
    set(value) = setTag(R.id.tag_last_click_time, value)

inline fun View.onDebouncedClick(
    interval: Long = 500L,
    crossinline action: () -> Unit
) {
    setOnClickListener {
        val now = System.currentTimeMillis()
        if (now - lastClickTime >= interval) {
            lastClickTime = now
            action()
        }
    }
}

/**
 * TextView 文本设置扩展
 */
fun TextView.setTextOrHide(text: String?) {
    if (text.isNullOrEmpty()) {
        gone()
    } else {
        visible()
        this.text = text
    }
}

9.2 案例二：Ktor HTTP 扩展

package com.example.ktorext

import io.ktor.server.application.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import io.ktor.util.pipeline.*

/**
 * Pipeline Context 扩展
 */
suspend fun PipelineContext<*, ApplicationCall>.respondJson(data: Any) {
    call.respond(data)
}

suspend fun PipelineContext<*, ApplicationCall>.requireHeader(name: String): String {
    return call.request.headers[name] ?: throw IllegalArgumentException("Missing header: $name")
}

/**
 * ApplicationCall 扩展
 */
fun ApplicationCall.clientIp(): String =
    request.headers["X-Forwarded-For"]?.split(",")?.firstOrNull()?.trim()
        ?: request.local.remoteHost

fun ApplicationCall.bearerToken(): String? =
    request.headers["Authorization"]?.removePrefix("Bearer ")?.trim()

9.3 案例三：Compose Multiplatform 扩展

package com.example.composeext

import androidx.compose.foundation.layout.*
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

/**
 * Modifier 扩展，链式 API
 */
fun Modifier.square(size: Int): Modifier = this.size(size.dp)

fun Modifier.centerHorizontally(): Modifier = this.fillMaxWidth().wrapContentWidth(align = androidx.compose.ui.Alignment.CenterHorizontally)

@Composable
fun Modifier.ifTrue(condition: Boolean, transform: Modifier.() -> Modifier): Modifier =
    if (condition) transform() else this

/**
 * Box 扩展
 */
@Composable
fun BoxWithSize(
    content: @Composable BoxWithSizeScope.() -> Unit
) {
    Box {
        content()
    }
}

9.4 案例四：标准库源码分析

分析 kotlin-stdlib 中的 String.isBlank()：

// kotlin-stdlib 源码
public CharSequence?.isBlank(): Boolean {
    val length: Int = this?.length ?: return true
    var i = 0
    if (i == length) return true
    while (i < length) {
        if (!this[i].isWhitespace()) return false
        i++
    }
    return true
}

设计要点：

1. 接收者为 CharSequence?，支持 null。
2. 通过循环判断是否全部为空白字符。
3. 时间复杂度 $O(n)$，空间复杂度 $O(1)$。

9.5 案例五：Arrow-kt 库扩展

package com.example.arrowext

import arrow.core.Either
import arrow.core.left
import arrow.core.right

/**
 * 为 Either 添加扩展
 */
fun <L, R> Either<L, R>.getOrElse(default: R): R = when (this) {
    is Either.Left -> default
    is Either.Right -> value
}

fun <L, R, T> Either<L, R>.map(transform: (R) -> T): Either<L, T> = when (this) {
    is Either.Left -> this
    is Either.Right -> transform(value).right()
}

fun <L, R, T> Either<L, R>.flatMap(transform: (R) -> Either<L, T>): Either<L, T> = when (this) {
    is Either.Left -> this
    is Either.Right -> transform(value)
}

10. 习题

10.1 选择题

题目 1：以下关于 Kotlin 扩展函数的描述，哪一项是错误的？

A. 扩展函数在编译期静态解析 B. 扩展函数可以访问接收者的 private 成员 C. 扩展函数可以接受 nullable 接收者 D. 扩展函数与成员函数冲突时，成员函数优先

答案：B

解析：扩展函数本质上是外部静态方法，无法访问接收者的 private 成员。private 成员的可见性限制在类内部，扩展函数虽然语法上看起来像成员函数，但编译后是独立的方法，因此无法突破封装。

题目 2：以下代码的输出是？

open class Shape
class Circle : Shape()
class Square : Shape()

fun Shape.draw() = "Drawing shape"
fun Circle.draw() = "Drawing circle"

fun main() {
    val shape: Shape = Circle()
    println(shape.draw())
}

A. “Drawing circle” B. “Drawing shape” C. 编译错误 D. 运行时异常

答案：B

解析：扩展函数是静态分发的，基于变量的声明类型。shape 的声明类型是 Shape，因此编译器选择 Shape.draw() 扩展函数，即使运行时实际类型是 Circle。

题目 3：以下关于 @JvmName 注解的描述，哪一项是正确的？

A. @JvmName 修改 Kotlin 源代码中的函数名 B. @JvmName 仅在 Kotlin/JS 中有效 C. @JvmName 指定编译后的 JVM 方法名 D. @JvmName 影响扩展函数的解析优先级

答案：C

解析：@JvmName 注解用于指定 Kotlin 代码编译为 JVM 字节码时的方法名，常用于解决平台命名冲突（如 JVM 签名擦除导致的重载冲突）。

题目 4：以下扩展函数的接收者类型是什么？

fun String?.isNullOrBlank(): Boolean = this == null || this.isBlank()

A. String B. String? C. Any? D. Nothing?

答案：B

解析：String? 是接收者类型，this 可能为 null。这是 Kotlin 扩展函数的特殊能力，允许在接收者为 null 时调用。

题目 5：Kotlin 2.0 的 K2 编译器相比 K1，在扩展函数方面的主要改进是？

A. 支持动态分发 B. 允许扩展函数访问 private 成员 C. 编译速度提升约 2-3 倍 D. 扩展函数可以继承

答案：C

解析：K2 编译器采用新的架构，在重载解析、IR 优化方面有显著提升，编译速度提升约 2-3 倍。但扩展函数的核心语义（静态分发、不修改原类）保持不变。

10.2 填空题

题目 1：扩展函数在编译后，接收者 this 会作为方法的 ________ 参数传入。

答案：第一个

解析：扩展函数 fun T.f() 编译为静态方法 f(T receiver)，接收者成为第一个参数。

题目 2：扩展函数与成员函数冲突时，________ 函数优先。

答案：成员

解析：Kotlin 语言规范明确规定，成员函数优先级高于扩展函数。

题目 3：扩展属性不能有 ________ field，因此不能存储状态。

答案：backing

解析：扩展属性本质上是一对 getter/setter 函数，没有字段存储空间。

题目 4：Kotlin 扩展函数的灵感主要来源于 ________ 语言的扩展方法。

答案：C#

解析：C# 在 3.0 版本引入了扩展方法（Extension Methods），Kotlin 借鉴了这一概念。

题目 5：扩展函数 fun String.foo() 编译后所在的类名默认是 ________。

答案：文件名 + Kt（如 StringKt）

解析：Kotlin 将顶层函数（包括扩展函数）编译到以源文件名命名的类中，可通过 @file:JvmName 自定义。

10.3 编程题

题目 1：实现一个扩展函数 List<T>.partition，将列表按谓词分为两组。

参考答案：

fun <T> List<T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>> {
    val first = ArrayList<T>()
    val second = ArrayList<T>()
    for (item in this) {
        if (predicate(item)) first.add(item) else second.add(item)
    }
    return Pair(first, second)
}

fun main() {
    val (evens, odds) = listOf(1, 2, 3, 4, 5).partition { it % 2 == 0 }
    println("Evens: $evens")  // [2, 4]
    println("Odds: $odds")   // [1, 3, 5]
}

评分要点：

1. 正确使用泛型 <T>。
2. 遍历列表，按谓词分组。
3. 返回 Pair<List<T>, List<T>>。
4. 处理空列表情况。

题目 2：为 Result<T> 实现 map 和 flatMap 扩展函数。

参考答案：

fun <T, R> Result<T>.map(transform: (T) -> R): Result<R> =
    fold({ Result.success(transform(it)) }, { Result.failure(it) })

fun <T, R> Result<T>.flatMap(transform: (T) -> Result<R>): Result<R> =
    fold({ transform(it) }, { Result.failure(it) })

fun main() {
    val result = Result.success(10)
        .map { it * 2 }
        .flatMap { Result.success(it + 5) }
    println(result)  // Success(25)
}

题目 3：实现一个简单的 SQL DSL，使用扩展函数 + 类型约束。

参考答案：

@DslMarker
annotation class SqlDsl

@SqlDsl
class SqlBuilder {
    private val columns = mutableListOf<String>()
    private var table: String = ""
    private var whereClause: String = ""

    fun select(vararg cols: String) {
        columns.addAll(cols)
    }

    fun from(table: String) {
        this.table = table
    }

    fun where(condition: String) {
        whereClause = condition
    }

    fun build(): String {
        val cols = if (columns.isEmpty()) "*" else columns.joinToString(", ")
        var sql = "SELECT $cols FROM $table"
        if (whereClause.isNotEmpty()) {
            sql += " WHERE $whereClause"
        }
        return sql
    }
}

fun sql(block: SqlBuilder.() -> Unit): String {
    val builder = SqlBuilder()
    builder.block()
    return builder.build()
}

fun main() {
    val query = sql {
        select("id", "name", "email")
        from("users")
        where("age > 18")
    }
    println(query)  // SELECT id, name, email FROM users WHERE age > 18
}

10.4 思考题

题目 1：扩展函数是静态分发的，这意味着它不能用于实现多态。请讨论：在什么场景下应该使用扩展函数，什么场景下应该使用成员函数？

参考答案：

使用扩展函数的场景：

1. 为第三方库的类添加功能，无法修改源码。
2. 为系统类（如 String、List）添加项目特定的工具方法。
3. 在 DSL 中使用，提升可读性。
4. 工具函数无需访问类的 private 成员。

使用成员函数的场景：

1. 需要动态分发（多态）。
2. 需要访问 private 成员。
3. 函数是类的核心职责，应与类一起演进。
4. 需要在子类中 override。

题目 2：JetBrains 选择静态分发而非动态分发，请从类型安全、性能、二进制兼容性三个维度分析这一设计决策的优劣。

参考答案：

类型安全：

• 优势：静态分发在编译期确定调用目标，类型检查更严格。
• 劣势：失去运行时多态能力，可能导致与预期不符的行为。

性能：

• 优势：无虚方法调用开销，可被内联优化。
• 劣势：无法利用 JVM 的虚方法优化（如内联缓存）。

二进制兼容性：

• 优势：扩展函数添加/移除不影响原有类的二进制兼容性。
• 劣势：扩展函数的添加/移除需要调用方重新编译。

总体而言，JetBrains 的选择更适合 Kotlin 作为”更好的 Java”的定位，强调静态类型安全与性能。

题目 3：Kotlin 2.0 的 K2 编译器对扩展函数有哪些改进？这些改进如何影响库设计与性能？

参考答案：

K2 编译器的改进：

1. 编译速度：扩展函数的重载解析速度提升 2-3 倍。
2. IR 优化：更好的内联展开、死代码消除、接收者消除。
3. 诊断质量：扩展函数冲突时提供更详细的错误信息。
4. 跨平台一致性：JVM、JS、Native、Wasm 行为完全一致。

对库设计的影响：

1. 可以更激进地使用扩展函数，编译速度不再是瓶颈。
2. IR 优化使得 inline 扩展函数的开销进一步降低。
3. 更严格的诊断帮助库作者发现潜在的二进制兼容性问题。

对性能的影响：

1. 字节码体积减小（桥接方法减少）。
2. 运行时性能提升（更激进的内联）。
3. 启动速度提升（更小的字节码）。

题目 4：讨论扩展函数在团队代码规范中应如何使用？请给出一份决策树。

参考答案：

决策树：

是否需要为类添加新功能？
├── 否 → 不使用扩展函数
└── 是 → 是否能修改类的源码？
    ├── 能 → 使用成员函数
    └── 否 → 是否需要动态分发？
        ├── 是 → 使用接口 + 适配器模式
        └── 否 → 是否需要访问 private 成员？
            ├── 是 → 使用成员函数（如果可以）
            └── 否 → 使用扩展函数

规范要点：

1. 扩展函数按接收者类型分文件组织。
2. 公共扩展函数需要 @SinceKotlin 标注版本。
3. 避免为 final 类（如 String）添加与未来可能新增的成员函数同名的扩展。
4. 使用 @JvmName 解决跨平台命名冲突。
5. 测试覆盖扩展函数的所有分支。

题目 5：扩展函数与 Rust 的 trait 在设计哲学上有何异同？请从可扩展性、类型安全、性能三个维度对比。

参考答案：

Kotlin 的扩展函数更灵活，但牺牲了 Rust 的孤儿规则带来的安全性。Rust 的 trait 设计更严格，避免了命名冲突，但灵活性较低。

题目 6：分析以下代码，找出所有问题并改进：

fun String?.toNonNull(): String = this ?: ""
fun Int?.safePlus(other: Int?): Int = (this ?: 0) + (other ?: 0)
fun List<Int>.averageOrNull(): Double? = if (isEmpty()) null else average()

参考答案：

问题分析：

1. toNonNull()：扩展属性更合适，但接收者是 nullable。
2. safePlus()：使用扩展函数的语义不清晰，应使用普通函数。
3. averageOrNull()：仅支持 List<Int>，应泛化为 List<Double> 或使用 Iterable。

改进：

fun String?.orEmpty(): String = this ?: ""

fun Int?.orZero(): Int = this ?: 0

fun <T : Number> Iterable<T>.averageOrNull(): Double? =
    if (isEmpty()) null else map { it.toDouble() }.average()

fun main() {
    val s: String? = null
    println(s.orEmpty())  // ""

    val n: Int? = null
    println(n.orZero())  // 0

    println(listOf(1, 2, 3).averageOrNull())  // 2.0
}

题目 7：扩展函数在哪些场景下会导致内存泄漏？如何避免？

参考答案：

场景：

1. 扩展函数持有长生命周期对象引用（如 Activity 中的 View 扩展持有 Activity 引用）。
2. 扩展函数中启动协程但未在适当时候取消。
3. 扩展属性使用外部 Map 缓存，未及时清理。

避免方案：

1. 使用 WeakReference 持有引用。
2. 协程绑定到适当的作用域（viewModelScope、lifecycleScope）。
3. 使用 ConcurrentHashMap 并定期清理。
4. 在 onDestroy 中显式清理。

题目 8：讨论扩展函数在 Kotlin 标准库中的角色，列举至少 5 个核心扩展函数并说明其设计意图。

参考答案：

1. String.isBlank()：为 CharSequence 添加空白判断，支持 nullable 接收者。
2. List<T>.map { }：为集合添加函数式变换能力，内联优化性能。
3. T.let { }：作用域函数，将对象作为参数传入 lambda。
4. T.apply { }：作用域函数，配置对象后返回对象本身。
5. Iterable<T>.partition { }：按谓词分组，返回 Pair。
6. Iterable<T>.windowed(size)：滑动窗口分块。
7. Sequence<T>.flatten()：扁平化嵌套序列。

设计意图：标准库通过扩展函数为已有类添加功能，避免修改类定义，同时保持 API 简洁。

题目 9：如何为 sealed 类的扩展函数保证穷尽性？举例说明。

参考答案：

Kotlin 编译器对 when 表达式中的 sealed 类进行穷尽性检查。在扩展函数中使用 when 时，必须覆盖所有子类：

sealed class Shape {
    data class Circle(val radius: Double) : Shape()
    data class Square(val side: Double) : Shape()
    data class Triangle(val a: Double, val b: Double, val c: Double) : Shape()
}

fun Shape.area(): Double = when (this) {
    is Shape.Circle -> Math.PI * radius * radius
    is Shape.Square -> side * side
    is Shape.Triangle -> {
        val s = (a + b + c) / 2
        Math.sqrt((s - a) * (s - b) * (s - c) * s)
    }
}

fun main() {
    val shape: Shape = Shape.Circle(5.0)
    println(shape.area())  // 78.53981633974483
}

如果未来新增 Shape.Rectangle，编译器会报错提示扩展函数 area() 需要更新。

题目 10：分析扩展函数在编译后字节码层面与普通顶层函数的区别。

参考答案：

字节码层面，扩展函数与普通顶层函数的主要区别：

1. 参数列表：扩展函数多一个接收者参数作为第一个参数。
2. 元数据注解：扩展函数的 @kotlin.Metadata 中包含 ReceiverType 信息。
3. 可见性：扩展函数的可见性由源码的修饰符决定（默认 public）。
4. 内联标记：inline 扩展函数有 ACC_INLINE 标记。

字节码反汇编示例：

// 普通顶层函数
public static final void topLevel() {
    System.out.println("top level");
}

// 扩展函数
public static final void extensionOnString(String receiver) {
    System.out.println("extension on " + receiver);
}

二者在 JVM 层面没有本质区别，只是扩展函数多了一个参数。

10.5 综合应用题

题目 1：设计一个类型安全的 HTTP 客户端 DSL，使用扩展函数 + 内联函数 + 类型参数约束。

参考答案：

package com.example.httpdsl

@DslMarker
annotation class HttpClientDsl

@HttpClientDsl
class HttpRequestBuilder {
    var url: String = ""
    var method: HttpMethod = HttpMethod.GET
    private val headers = mutableMapOf<String, String>()
    private var body: String = ""

    fun header(key: String, value: String) {
        headers[key] = value
    }

    fun body(content: String) {
        body = content
    }

    fun build(): HttpRequest = HttpRequest(url, method, headers.toMap(), body)
}

enum class HttpMethod { GET, POST, PUT, DELETE }

data class HttpRequest(
    val url: String,
    val method: HttpMethod,
    val headers: Map<String, String>,
    val body: String
)

class HttpResponse(val status: Int, val body: String)

inline fun httpRequest(block: HttpRequestBuilder.() -> Unit): HttpRequest {
    val builder = HttpRequestBuilder()
    builder.block()
    return builder.build()
}

suspend fun HttpRequest.execute(): HttpResponse {
    // 模拟 HTTP 请求
    return HttpResponse(200, "OK")
}

fun HttpRequestBuilder.get(url: String, block: HttpRequestBuilder.() -> Unit = {}) {
    this.url = url
    this.method = HttpMethod.GET
    block()
}

fun HttpRequestBuilder.post(url: String, block: HttpRequestBuilder.() -> Unit = {}) {
    this.url = url
    this.method = HttpMethod.POST
    block()
}

fun main() {
    val request = httpRequest {
        post("https://api.example.com/users") {
            header("Content-Type", "application/json")
            body("""{"name": "Alice"}""")
        }
    }
    println(request)
}