// ❌ 可变状态带来的问题示例
class BankAccount {
    var balance: Double = 0.0  // 可变状态 (mutable state)
    
    fun deposit(amount: Double) {
        balance += amount  // 直接修改状态
    }
    
    fun withdraw(amount: Double) {
        balance -= amount  // 直接修改状态
    }
}
 
// 在多线程环境下，这段代码可能产生竞态条件 (race condition)
// 线程A和线程B同时读取 balance = 100
// 线程A: balance = 100 + 50 = 150
// 线程B: balance = 100 - 30 = 70
// 最终结果取决于谁后写入，可能是 150 或 70，而不是正确的 120

// ✅ 不可变设计 (immutable design)
data class BankAccount(
    val balance: Double  // 使用 val 声明不可变属性
) {
    // 不修改原对象，而是返回新对象
    fun deposit(amount: Double): BankAccount {
        return copy(balance = balance + amount)  // 创建新实例
    }
    
    // 同样返回新对象
    fun withdraw(amount: Double): BankAccount {
        return copy(balance = balance - amount)  // 创建新实例
    }
}
 
// 使用示例
fun main() {
    val account1 = BankAccount(100.0)           // 初始账户
    val account2 = account1.deposit(50.0)       // 存款后的新账户
    val account3 = account2.withdraw(30.0)      // 取款后的新账户
    
    println(account1.balance)  // 100.0 - 原账户不变！
    println(account2.balance)  // 150.0
    println(account3.balance)  // 120.0
}

// 1. 使用 val 而非 var
val name = "Kotlin"           // 不可变引用 (immutable reference)
// name = "Java"              // ❌ 编译错误！
 
// 2. 使用不可变集合 (immutable collections)
val numbers = listOf(1, 2, 3)           // 不可变列表
val mapping = mapOf("a" to 1, "b" to 2) // 不可变映射
val unique = setOf(1, 2, 3)             // 不可变集合
 
// 3. 使用 data class 配合 copy() 方法
data class User(
    val id: Long,
    val name: String,
    val email: String
)
 
val user1 = User(1, "Alice", "alice@example.com")
val user2 = user1.copy(email = "newalice@example.com")  // 只修改 email
 
// 4. 注意：val 只保证引用不可变，不保证内容不可变！
val mutableList = mutableListOf(1, 2, 3)
// mutableList = mutableListOf(4, 5, 6)  // ❌ 引用不可变
mutableList.add(4)                        // ✅ 但内容可以修改！

┌─────────────────────────────────────────────────────────────┐
│  val 的真正含义：引用不可变 vs 内容不可变                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  val list = mutableListOf(1, 2, 3)                         │
│                                                             │
│  list ─────────────────► MutableList [1, 2, 3, 4]          │
│    ↑                            ↑                          │
│  引用锁定                      内容可变                      │
│  (reference locked)         (content mutable)              │
│                                                             │
│  ════════════════════════════════════════════════════════  │
│                                                             │
│  val list = listOf(1, 2, 3)    // 真正的不可变              │
│                                                             │
│  list ─────────────────► List [1, 2, 3]                    │
│    ↑                            ↑                          │
│  引用锁定                      内容也锁定                    │
│  (reference locked)         (content locked)               │
│                                                             │
└─────────────────────────────────────────────────────────────┘

// ═══════════════════════════════════════════════════════════
// ✅ 纯函数示例 (Pure Functions)
// ═══════════════════════════════════════════════════════════
 
// 纯函数1：简单的数学计算
fun add(a: Int, b: Int): Int {
    return a + b  // 只依赖输入参数，无副作用
}
 
// 纯函数2：字符串处理
fun formatName(firstName: String, lastName: String): String {
    return "$lastName, $firstName"  // 确定性输出，无副作用
}
 
// 纯函数3：列表转换
fun doubleAll(numbers: List<Int>): List<Int> {
    return numbers.map { it * 2 }  // 返回新列表，不修改原列表
}
 
// 纯函数4：复杂业务逻辑也可以是纯的
data class Order(val items: List<Item>, val discount: Double)
data class Item(val name: String, val price: Double)
 
fun calculateTotal(order: Order): Double {
    val subtotal = order.items.sumOf { it.price }  // 计算小计
    return subtotal * (1 - order.discount)          // 应用折扣
    // 只依赖输入的 order，不访问任何外部状态
}

// ═══════════════════════════════════════════════════════════
// ❌ 非纯函数示例 (Impure Functions)
// ═══════════════════════════════════════════════════════════
 
// 非纯函数1：依赖外部可变状态
var taxRate = 0.1  // 外部可变状态
 
fun calculateTax(amount: Double): Double {
    return amount * taxRate  // ❌ 依赖外部变量，taxRate 变化会影响结果
}
 
// 非纯函数2：修改外部状态（副作用）
var totalSales = 0.0
 
fun recordSale(amount: Double): Double {
    totalSales += amount  // ❌ 副作用：修改了外部变量
    return amount
}
 
// 非纯函数3：依赖系统状态
fun getCurrentTimeGreeting(): String {
    val hour = java.time.LocalTime.now().hour  // ❌ 依赖系统时间
    return when {
        hour < 12 -> "Good morning"
        hour < 18 -> "Good afternoon"
        else -> "Good evening"
    }
}
 
// 非纯函数4：I/O 操作
fun readUserInput(): String {
    print("Enter your name: ")
    return readLine() ?: ""  // ❌ 依赖外部输入，每次可能不同
}
 
// 非纯函数5：随机数
fun rollDice(): Int {
    return (1..6).random()  // ❌ 不确定性输出
}

// ═══════════════════════════════════════════════════════════
// 改造示例：将非纯函数转化为纯函数
// ═══════════════════════════════════════════════════════════
 
// 改造前：依赖外部 taxRate
var taxRate = 0.1
fun calculateTax(amount: Double): Double = amount * taxRate
 
// ✅ 改造后：将 taxRate 作为参数传入
fun calculateTaxPure(amount: Double, taxRate: Double): Double {
    return amount * taxRate  // 现在是纯函数了！
}
 
// ─────────────────────────────────────────────────────────────
 
// 改造前：依赖系统时间
fun getCurrentTimeGreeting(): String {
    val hour = java.time.LocalTime.now().hour
    return when {
        hour < 12 -> "Good morning"
        hour < 18 -> "Good afternoon"
        else -> "Good evening"
    }
}
 
// ✅ 改造后：将时间作为参数传入
fun getGreetingForHour(hour: Int): String {
    return when {
        hour < 12 -> "Good morning"
        hour < 18 -> "Good afternoon"
        else -> "Good evening"
    }
}
 
// 使用时在"边界"处注入实际时间
fun main() {
    val currentHour = java.time.LocalTime.now().hour  // 副作用隔离在边界
    val greeting = getGreetingForHour(currentHour)     // 纯函数调用
    println(greeting)                                   // 副作用隔离在边界
}

// ═══════════════════════════════════════════════════════════
// 纯函数的可测试性优势
// ═══════════════════════════════════════════════════════════
 
// 纯函数极易测试 - 不需要 mock，不需要设置环境
fun testGetGreetingForHour() {
    // 测试边界条件，完全确定性
    assert(getGreetingForHour(0) == "Good morning")
    assert(getGreetingForHour(11) == "Good morning")
    assert(getGreetingForHour(12) == "Good afternoon")
    assert(getGreetingForHour(17) == "Good afternoon")
    assert(getGreetingForHour(18) == "Good evening")
    assert(getGreetingForHour(23) == "Good evening")
    // 每次运行结果都一样，不受时间影响！
}
 
// ═══════════════════════════════════════════════════════════
// 纯函数的可缓存性（记忆化 Memoization）
// ═══════════════════════════════════════════════════════════
 
// 因为纯函数相同输入必定相同输出，所以可以安全缓存
fun <T, R> memoize(function: (T) -> R): (T) -> R {
    val cache = mutableMapOf<T, R>()  // 缓存映射
    return { input: T ->
        cache.getOrPut(input) {       // 有缓存就用缓存
            function(input)            // 没有就计算并存入
        }
    }
}
 
// 使用示例：斐波那契数列
val fibonacci: (Int) -> Long = memoize { n: Int ->
    if (n <= 1) n.toLong()
    else fibonacci(n - 1) + fibonacci(n - 2)
}

// ═══════════════════════════════════════════════════════════
// 引用透明示例
// ═══════════════════════════════════════════════════════════
 
// 纯函数
fun square(x: Int): Int = x * x
 
// 以下两段代码完全等价（引用透明）
val result1 = square(4) + square(4)  // 使用函数调用
val result2 = 16 + 16                 // 直接使用值替换
 
// 我们可以安全地用 16 替换 square(4)，程序行为不变
// 这就是引用透明 (referential transparency)
 
// ─────────────────────────────────────────────────────────────
 
// ❌ 非引用透明的例子
var counter = 0
 
fun incrementAndGet(): Int {
    counter += 1      // 副作用：修改外部状态
    return counter
}
 
// 以下两段代码 **不等价**！
val a1 = incrementAndGet() + incrementAndGet()  // 1 + 2 = 3
val a2 = 1 + 1                                   // 2
 
// incrementAndGet() 不能被它的返回值替换
// 因为每次调用都会改变 counter 的状态
// 这就是 **非引用透明** (not referentially transparent)

// ═══════════════════════════════════════════════════════════
// 引用透明使代码推理变得简单
// ═══════════════════════════════════════════════════════════
 
// 考虑这个复杂表达式
fun processOrder(order: Order): ProcessedOrder {
    val validated = validateOrder(order)           // 纯函数
    val priced = calculatePricing(validated)       // 纯函数
    val discounted = applyDiscounts(priced)        // 纯函数
    return finalizeOrder(discounted)               // 纯函数
}
 
// 因为每个函数都是纯的、引用透明的，我们可以：
// 1. 独立测试每个函数
// 2. 安全地重排序（如果没有数据依赖）
// 3. 并行执行独立的计算
// 4. 缓存中间结果
// 5. 用等价的值替换任何子表达式
 
// ═══════════════════════════════════════════════════════════
// 引用透明支持等式推理 (Equational Reasoning)
// ═══════════════════════════════════════════════════════════
 
// 数学证明风格的代码推理
// 假设有纯函数 f 和 g
fun f(x: Int): Int = x * 2
fun g(x: Int): Int = x + 1
 
// 我们可以进行代数变换
val expr1 = f(g(3))        // 原始表达式
val expr2 = f(3 + 1)       // 替换 g(3) 为其值
val expr3 = f(4)           // 计算 3 + 1
val expr4 = 4 * 2          // 替换 f(4) 为其定义
val expr5 = 8              // 最终结果
 
// 每一步替换都是安全的，因为函数是引用透明的

// 函数A
var multiplier = 2
fun multiplyA(x: Int): Int = x * multiplier
 
// 函数B
fun multiplyB(x: Int, multiplier: Int): Int = x * multiplier
 
// 函数C
fun multiplyC(x: Int): Int {
    println("Calculating...")
    return x * 2
}
 
// 函数D
fun multiplyD(x: Int): Int = x * Random.nextInt(10)

// ═══════════════════════════════════════════════════════════
// 函数类型的语法：(参数类型列表) -> 返回类型
// ═══════════════════════════════════════════════════════════
 
// 无参数，返回 Unit 的函数类型
val greet: () -> Unit = { println("Hello!") }
 
// 接收一个 Int，返回 Int 的函数类型
val square: (Int) -> Int = { x -> x * x }
 
// 接收两个参数的函数类型
val add: (Int, Int) -> Int = { a, b -> a + b }
 
// 接收 String，返回 Boolean 的函数类型
val isLongString: (String) -> Boolean = { it.length > 10 }
 
// 复杂类型：接收函数作为参数的函数类型
val transformer: ((Int) -> Int, Int) -> Int = { func, value -> 
    func(value) 
}

// ═══════════════════════════════════════════════════════════
// 函数引用 (Function Reference) 使用 :: 操作符
// ═══════════════════════════════════════════════════════════
 
// 定义一个普通的具名函数
fun double(x: Int): Int {
    return x * 2
}
 
fun isEven(x: Int): Boolean {
    return x % 2 == 0
}
 
fun main() {
    // 使用 :: 获取函数引用，赋值给变量
    val doubleFunc: (Int) -> Int = ::double
    val evenChecker: (Int) -> Boolean = ::isEven
    
    // 通过变量调用函数
    println(doubleFunc(5))      // 输出: 10
    println(evenChecker(4))     // 输出: true
    
    // 函数引用可以直接用于高阶函数
    val numbers = listOf(1, 2, 3, 4, 5)
    val doubled = numbers.map(::double)        // [2, 4, 6, 8, 10]
    val evens = numbers.filter(::isEven)       // [2, 4]
}

// ═══════════════════════════════════════════════════════════
// Lambda 表达式的各种写法
// ═══════════════════════════════════════════════════════════
 
// 完整写法：显式声明参数类型
val sum1: (Int, Int) -> Int = { a: Int, b: Int -> a + b }
 
// 简化写法：类型推断参数类型
val sum2: (Int, Int) -> Int = { a, b -> a + b }
 
// 单参数时可以使用 it 关键字
val square1: (Int) -> Int = { x -> x * x }  // 显式参数名
val square2: (Int) -> Int = { it * it }      // 使用 it
 
// 多行 Lambda，最后一个表达式是返回值
val complexOperation: (Int) -> String = { number ->
    val doubled = number * 2           // 中间计算
    val squared = doubled * doubled    // 更多计算
    "Result: $squared"                 // 最后一行是返回值
}
 
// 无参数的 Lambda
val sayHello: () -> Unit = { println("Hello, Kotlin!") }
 
// 调用示例
fun main() {
    println(sum1(3, 4))              // 输出: 7
    println(square2(5))              // 输出: 25
    println(complexOperation(3))     // 输出: Result: 36
    sayHello()                       // 输出: Hello, Kotlin!
}

// ═══════════════════════════════════════════════════════════
// 匿名函数 vs Lambda 表达式
// ═══════════════════════════════════════════════════════════
 
// Lambda 表达式
val sumLambda: (Int, Int) -> Int = { a, b -> a + b }
 
// 匿名函数 - 使用 fun 关键字但没有函数名
val sumAnonymous: (Int, Int) -> Int = fun(a: Int, b: Int): Int {
    return a + b  // 可以使用 return 语句
}
 
// 匿名函数的优势：可以显式指定返回类型
val parser: (String) -> Int = fun(s: String): Int {
    return s.toIntOrNull() ?: 0  // 明确的返回类型
}
 
// 匿名函数中的 return 只返回该函数
// Lambda 中的 return 会返回外层函数（非局部返回）
fun processNumbers(numbers: List<Int>): List<Int> {
    // Lambda 中的 return 会直接返回 processNumbers 函数！
    // return numbers.map { if (it < 0) return emptyList() else it * 2 }
    
    // 匿名函数中的 return 只返回当前匿名函数
    return numbers.map(fun(n: Int): Int {
        if (n < 0) return 0  // 只返回这个匿名函数，不影响外层
        return n * 2
    })
}

// ═══════════════════════════════════════════════════════════
// 函数作为参数的基本用法
// ═══════════════════════════════════════════════════════════
 
// 定义一个接收函数参数的高阶函数
fun applyOperation(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return operation(x, y)  // 调用传入的函数
}
 
// 定义几个可以传递的操作函数
fun add(a: Int, b: Int) = a + b
fun subtract(a: Int, b: Int) = a - b
fun multiply(a: Int, b: Int) = a * b
 
fun main() {
    // 方式1：传递函数引用
    val sum = applyOperation(10, 5, ::add)           // 15
    val diff = applyOperation(10, 5, ::subtract)     // 5
    val product = applyOperation(10, 5, ::multiply)  // 50
    
    // 方式2：传递 Lambda 表达式
    val quotient = applyOperation(10, 5) { a, b -> a / b }  // 2
    val power = applyOperation(2, 8) { base, exp -> 
        var result = 1
        repeat(exp) { result *= base }
        result  // Lambda 最后一行是返回值
    }  // 256
    
    // 方式3：传递已存储在变量中的函数
    val modulo: (Int, Int) -> Int = { a, b -> a % b }
    val remainder = applyOperation(10, 3, modulo)    // 1
}

// ═══════════════════════════════════════════════════════════
// 标准库中的函数传递示例
// ═══════════════════════════════════════════════════════════
 
data class Person(
    val name: String,
    val age: Int,
    val city: String
)
 
fun main() {
    val people = listOf(
        Person("Alice", 28, "Beijing"),
        Person("Bob", 35, "Shanghai"),
        Person("Charlie", 22, "Beijing"),
        Person("Diana", 31, "Guangzhou")
    )
    
    // filter: 传递判断函数 (predicate)
    val adults = people.filter { it.age >= 25 }  // 筛选25岁以上
    
    // map: 传递转换函数 (transform)
    val names = people.map { it.name }  // 提取所有名字
    
    // sortedBy: 传递选择器函数 (selector)
    val byAge = people.sortedBy { it.age }  // 按年龄排序
    
    // groupBy: 传递分组键函数
    val byCity = people.groupBy { it.city }  // 按城市分组
    
    // any/all/none: 传递判断函数
    val hasYoung = people.any { it.age < 25 }    // 是否有年轻人
    val allAdults = people.all { it.age >= 18 }  // 是否都成年
    
    // fold: 传递累积函数 (accumulator)
    val totalAge = people.fold(0) { acc, person -> 
        acc + person.age  // 累加年龄
    }
    
    // 链式调用：多个函数传递组合
    val result = people
        .filter { it.city == "Beijing" }     // 筛选北京人
        .map { it.name.uppercase() }          // 名字转大写
        .sorted()                             // 排序
    // result: [ALICE, CHARLIE]
}

// ═══════════════════════════════════════════════════════════
// 返回函数的基本语法
// ═══════════════════════════════════════════════════════════
 
// 返回一个加法函数
fun createAdder(n: Int): (Int) -> Int {
    // 返回一个 Lambda，它会将输入加上 n
    return { x -> x + n }
}
 
// 返回一个乘法函数
fun createMultiplier(factor: Int): (Int) -> Int {
    return { x -> x * factor }
}
 
fun main() {
    // 创建特定的函数实例
    val addFive = createAdder(5)       // 创建"加5"函数
    val addTen = createAdder(10)       // 创建"加10"函数
    val double = createMultiplier(2)   // 创建"乘2"函数
    val triple = createMultiplier(3)   // 创建"乘3"函数
    
    // 使用这些函数
    println(addFive(3))   // 8  (3 + 5)
    println(addTen(3))    // 13 (3 + 10)
    println(double(7))    // 14 (7 * 2)
    println(triple(7))    // 21 (7 * 3)
    
    // 可以继续传递这些函数
    val numbers = listOf(1, 2, 3, 4, 5)
    println(numbers.map(addFive))   // [6, 7, 8, 9, 10]
    println(numbers.map(double))    // [2, 4, 6, 8, 10]
}

// ═══════════════════════════════════════════════════════════
// 闭包：函数捕获外部变量
// ═══════════════════════════════════════════════════════════
 
// 闭包示例：计数器工厂
fun createCounter(start: Int = 0): () -> Int {
    var count = start  // 这个变量会被闭包捕获
    return {
        count++  // 每次调用都会修改并返回 count
    }
}
 
fun main() {
    val counter1 = createCounter()      // 从0开始
    val counter2 = createCounter(100)   // 从100开始
    
    // 每个计数器维护自己的状态
    println(counter1())  // 0
    println(counter1())  // 1
    println(counter1())  // 2
    
    println(counter2())  // 100
    println(counter2())  // 101
    
    // counter1 和 counter2 是独立的，各自有自己的 count 变量
    println(counter1())  // 3 (继续自己的计数)
}

┌─────────────────────────────────────────────────────────────┐
│  闭包的内存模型 (Closure Memory Model)                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  createCounter(0) 调用后:                                   │
│                                                             │
│  counter1 ──────► Lambda 对象                               │
│                      │                                      │
│                      └──► 捕获的环境 { count: 0 }           │
│                                  ↓                          │
│                           count: 0 → 1 → 2 → 3...          │
│                                                             │
│  createCounter(100) 调用后:                                 │
│                                                             │
│  counter2 ──────► Lambda 对象                               │
│                      │                                      │
│                      └──► 捕获的环境 { count: 100 }         │
│                                  ↓                          │
│                           count: 100 → 101 → 102...        │
│                                                             │
│  两个闭包各自维护独立的 count 变量副本                        │
└─────────────────────────────────────────────────────────────┘

// ═══════════════════════════════════════════════════════════
// 实用示例：验证器工厂
// ═══════════════════════════════════════════════════════════
 
// 创建字符串长度验证器
fun lengthValidator(min: Int, max: Int): (String) -> Boolean {
    return { str -> str.length in min..max }
}
 
// 创建正则表达式验证器
fun regexValidator(pattern: String): (String) -> Boolean {
    val regex = Regex(pattern)  // 编译一次，多次使用
    return { str -> regex.matches(str) }
}
 
// 创建范围验证器
fun rangeValidator(min: Int, max: Int): (Int) -> Boolean {
    return { value -> value in min..max }
}
 
fun main() {
    // 创建具体的验证器
    val usernameValidator = lengthValidator(3, 20)
    val emailValidator = regexValidator("^[\\w.-]+@[\\w.-]+\\.\\w+$")
    val ageValidator = rangeValidator(0, 150)
    
    // 使用验证器
    println(usernameValidator("ab"))           // false (太短)
    println(usernameValidator("alice"))        // true
    println(emailValidator("test@example.com")) // true
    println(ageValidator(25))                  // true
    println(ageValidator(200))                 // false
}

fun makeGreeter(greeting: String): (String) -> String {
    return { name -> "$greeting, $name!" }
}
 
fun main() {
    val sayHello = makeGreeter("Hello")
    val sayHi = makeGreeter("Hi")
    
    println(sayHello("Alice"))
    println(sayHi("Bob"))
    println(sayHello("Charlie"))
}

// ═══════════════════════════════════════════════════════════
// 传统 OOP：模板方法模式
// ═══════════════════════════════════════════════════════════
 
// 抽象类定义骨架
abstract class DataProcessor {
    // 模板方法：定义处理流程
    fun process(data: String): String {
        val validated = validate(data)      // 步骤1：验证
        val transformed = transform(validated) // 步骤2：转换（可变）
        return format(transformed)          // 步骤3：格式化
    }
    
    private fun validate(data: String): String {
        return data.trim()  // 固定的验证逻辑
    }
    
    abstract fun transform(data: String): String  // 子类实现
    
    private fun format(data: String): String {
        return "Result: $data"  // 固定的格式化逻辑
    }
}
 
// 需要为每种转换创建子类
class UpperCaseProcessor : DataProcessor() {
    override fun transform(data: String) = data.uppercase()
}
 
class ReversedProcessor : DataProcessor() {
    override fun transform(data: String) = data.reversed()
}

// ═══════════════════════════════════════════════════════════
// 函数式方式：高阶函数替代模板方法
// ═══════════════════════════════════════════════════════════
 
// 用高阶函数，无需继承，更加灵活
fun processData(
    data: String,
    transform: (String) -> String  // 将可变部分作为函数参数
): String {
    val validated = data.trim()           // 步骤1：验证（固定）
    val transformed = transform(validated) // 步骤2：转换（传入）
    return "Result: $transformed"          // 步骤3：格式化（固定）
}
 
fun main() {
    val input = "  Hello World  "
    
    // 直接传入不同的转换逻辑，无需创建类
    val upper = processData(input) { it.uppercase() }
    val reversed = processData(input) { it.reversed() }
    val length = processData(input) { "Length: ${it.length}" }
    
    println(upper)     // Result: HELLO WORLD
    println(reversed)  // Result: dlroW olleH
    println(length)    // Result: Length: 11
    
    // 甚至可以组合多个转换
    val complex = processData(input) { 
        it.uppercase().replace(" ", "_") 
    }
    println(complex)   // Result: HELLO_WORLD
}

// ═══════════════════════════════════════════════════════════
// 资源管理：将"使用资源"的逻辑作为函数传入
// ═══════════════════════════════════════════════════════════
 
import java.io.File
import java.io.BufferedReader
 
// 高阶函数：管理文件资源的生命周期
inline fun <T> useFile(
    path: String,
    operation: (BufferedReader) -> T  // 传入"如何使用文件"的函数
): T {
    val reader = File(path).bufferedReader()  // 打开资源
    return try {
        operation(reader)  // 执行用户逻辑
    } finally {
        reader.close()     // 确保关闭资源
    }
}
 
// 使用示例
fun main() {
    // 读取第一行
    val firstLine = useFile("data.txt") { reader ->
        reader.readLine()
    }
    
    // 读取所有行
    val allLines = useFile("data.txt") { reader ->
        reader.readLines()
    }
    
    // 统计行数
    val lineCount = useFile("data.txt") { reader ->
        reader.lineSequence().count()
    }
    
    // 用户只关心"做什么"，不用关心资源的打开和关闭
}
 
// Kotlin 标准库已提供类似功能：use 扩展函数
fun readFileKotlinWay(path: String): List<String> {
    return File(path).bufferedReader().use { reader ->
        reader.readLines()  // use 会自动关闭资源
    }
}

// ═══════════════════════════════════════════════════════════
// 执行上下文：计时、日志、事务等横切关注点
// ═══════════════════════════════════════════════════════════
 
// 计时器高阶函数
inline fun <T> measureTimeAndReturn(
    operationName: String,
    block: () -> T
): T {
    val startTime = System.currentTimeMillis()  // 记录开始时间
    val result = block()                         // 执行实际操作
    val duration = System.currentTimeMillis() - startTime
    println("$operationName took ${duration}ms")
    return result
}
 
// 重试机制高阶函数
inline fun <T> retry(
    times: Int,
    delay: Long = 1000L,
    block: () -> T
): T {
    var lastException: Exception? = null
    repeat(times) { attempt ->
        try {
            return block()  // 成功则直接返回
        } catch (e: Exception) {
            lastException = e
            println("Attempt ${attempt + 1} failed: ${e.message}")
            if (attempt < times - 1) {
                Thread.sleep(delay)  // 等待后重试
            }
        }
    }
    throw lastException ?: IllegalStateException("Retry failed")
}
 
// 使用示例
fun main() {
    // 自动计时
    val result = measureTimeAndReturn("Database query") {
        // 模拟耗时操作
        Thread.sleep(100)
        "Query result"
    }
    
    // 自动重试
    val data = retry(times = 3, delay = 500) {
        fetchDataFromNetwork()  // 可能失败的网络请求
    }
}
 
fun fetchDataFromNetwork(): String {
    // 模拟网络请求
    if (Math.random() < 0.7) throw RuntimeException("Network error")
    return "Data"
}

// ═══════════════════════════════════════════════════════════
// 传统策略模式：需要接口 + 多个实现类
// ═══════════════════════════════════════════════════════════
 
// 策略接口
interface PaymentStrategy {
    fun pay(amount: Double): String
}
 
// 具体策略实现
class CreditCardPayment(private val cardNumber: String) : PaymentStrategy {
    override fun pay(amount: Double): String {
        return "Paid $$amount with credit card $cardNumber"
    }
}
 
class PayPalPayment(private val email: String) : PaymentStrategy {
    override fun pay(amount: Double): String {
        return "Paid $$amount via PayPal ($email)"
    }
}
 
class CryptoPayment(private val walletAddress: String) : PaymentStrategy {
    override fun pay(amount: Double): String {
        return "Paid $$amount in crypto to $walletAddress"
    }
}
 
// 上下文类
class ShoppingCart(private var paymentStrategy: PaymentStrategy) {
    fun checkout(amount: Double): String {
        return paymentStrategy.pay(amount)
    }
    
    fun setPaymentStrategy(strategy: PaymentStrategy) {
        this.paymentStrategy = strategy
    }
}
 
// 使用
fun traditionalStrategyDemo() {
    val cart = ShoppingCart(CreditCardPayment("1234-5678"))
    println(cart.checkout(100.0))
    
    cart.setPaymentStrategy(PayPalPayment("user@example.com"))
    println(cart.checkout(50.0))
}

// ═══════════════════════════════════════════════════════════
// 函数式策略模式：用函数类型替代接口
// ═══════════════════════════════════════════════════════════
 
// 策略就是一个函数类型
typealias PaymentStrategy = (Double) -> String
 
// 策略工厂函数（替代具体策略类）
fun creditCardPayment(cardNumber: String): PaymentStrategy = { amount ->
    "Paid $$amount with credit card $cardNumber"
}
 
fun payPalPayment(email: String): PaymentStrategy = { amount ->
    "Paid $$amount via PayPal ($email)"
}
 
fun cryptoPayment(walletAddress: String): PaymentStrategy = { amount ->
    "Paid $$amount in crypto to $walletAddress"
}
 
// 上下文：直接使用函数
class ShoppingCartFP(private var paymentStrategy: PaymentStrategy) {
    fun checkout(amount: Double): String = paymentStrategy(amount)
    
    fun setPaymentStrategy(strategy: PaymentStrategy) {
        this.paymentStrategy = strategy
    }
}
 
// 使用
fun functionalStrategyDemo() {
    val cart = ShoppingCartFP(creditCardPayment("1234-5678"))
    println(cart.checkout(100.0))
    
    cart.setPaymentStrategy(payPalPayment("user@example.com"))
    println(cart.checkout(50.0))
    
    // 函数式的优势：可以即时创建新策略，无需定义新类
    cart.setPaymentStrategy { amount ->
        "Paid $$amount with gift card (remaining: $${500 - amount})"
    }
    println(cart.checkout(30.0))
    
    // 可以组合策略
    val discountedPayment: PaymentStrategy = { amount ->
        val discounted = amount * 0.9  // 9折
        creditCardPayment("1234-5678")(discounted) + " (10% discount applied)"
    }
    cart.setPaymentStrategy(discountedPayment)
    println(cart.checkout(100.0))
}

// ═══════════════════════════════════════════════════════════
// 排序策略：函数式实现
// ═══════════════════════════════════════════════════════════
 
data class Product(
    val name: String,
    val price: Double,
    val rating: Double,
    val salesCount: Int
)
 
// 排序策略类型
typealias SortStrategy<T> = (List<T>) -> List<T>
 
// 预定义的排序策略
object ProductSortStrategies {
    // 按价格升序
    val byPriceAsc: SortStrategy<Product> = { products ->
        products.sortedBy { it.price }
    }
    
    // 按价格降序
    val byPriceDesc: SortStrategy<Product> = { products ->
        products.sortedByDescending { it.price }
    }
    
    // 按评分降序
    val byRating: SortStrategy<Product> = { products ->
        products.sortedByDescending { it.rating }
    }
    
    // 按销量降序
    val bySales: SortStrategy<Product> = { products ->
        products.sortedByDescending { it.salesCount }
    }
    
    // 组合策略：先按评分，评分相同按价格
    val byRatingThenPrice: SortStrategy<Product> = { products ->
        products.sortedWith(
            compareByDescending<Product> { it.rating }
                .thenBy { it.price }
        )
    }
}
 
// 产品列表管理器
class ProductCatalog(private val products: List<Product>) {
    fun display(sortStrategy: SortStrategy<Product>): List<Product> {
        return sortStrategy(products)
    }
}
 
fun main() {
    val products = listOf(
        Product("Laptop", 999.0, 4.5, 1000),
        Product("Phone", 699.0, 4.8, 5000),
        Product("Tablet", 499.0, 4.2, 800),
        Product("Watch", 299.0, 4.8, 3000)
    )
    
    val catalog = ProductCatalog(products)
    
    // 使用不同策略
    println("By Price:")
    catalog.display(ProductSortStrategies.byPriceAsc).forEach { println(it) }
    
    println("\nBy Rating:")
    catalog.display(ProductSortStrategies.byRating).forEach { println(it) }
    
    // 动态创建策略
    val customStrategy: SortStrategy<Product> = { list ->
        list.sortedBy { it.name.length }  // 按名字长度排序
    }
    println("\nBy Name Length:")
    catalog.display(customStrategy).forEach { println(it) }
}

typealias Formatter = (String) -> String
 
fun createFormatter(prefix: String, suffix: String): Formatter {
    return { text -> "$prefix$text$suffix" }
}
 
val htmlBold: Formatter = { "<b>$it</b>" }
val addQuotes: Formatter = createFormatter("\"", "\"")
 
fun format(text: String, formatter: Formatter): String = formatter(text)
 
fun main() {
    println(format("Hello", htmlBold))
    println(format("World", addQuotes))
}

// ═══════════════════════════════════════════════════════════
// compose: 从右到左组合
// 数学表示: (f compose g)(x) = f(g(x))
// ═══════════════════════════════════════════════════════════
 
// 定义 compose 中缀函数
infix fun <A, B, C> ((B) -> C).compose(other: (A) -> B): (A) -> C {
    return { a: A -> 
        this(other(a))  // 先执行 other，再执行 this
    }
}
 
// 示例函数
val addOne: (Int) -> Int = { it + 1 }      // 加1
val double: (Int) -> Int = { it * 2 }       // 乘2
val square: (Int) -> Int = { it * it }      // 平方
 
fun main() {
    // compose: 从右到左执行
    val addThenDouble = double compose addOne  // 先加1，再乘2
    val doubleThenAdd = addOne compose double  // 先乘2，再加1
    
    println(addThenDouble(5))  // (5 + 1) * 2 = 12
    println(doubleThenAdd(5))  // (5 * 2) + 1 = 11
    
    // 三个函数组合
    val complex = square compose double compose addOne
    // 执行顺序: addOne -> double -> square
    println(complex(3))  // ((3 + 1) * 2)² = 64
}

// ═══════════════════════════════════════════════════════════
// andThen: 从左到右组合
// 表示: (f andThen g)(x) = g(f(x))
// ═══════════════════════════════════════════════════════════
 
// 定义 andThen 中缀函数
infix fun <A, B, C> ((A) -> B).andThen(other: (B) -> C): (A) -> C {
    return { a: A -> 
        other(this(a))  // 先执行 this，再执行 other
    }
}
 
fun main() {
    val addOne: (Int) -> Int = { it + 1 }
    val double: (Int) -> Int = { it * 2 }
    val toString: (Int) -> String = { "Result: $it" }
    
    // andThen: 从左到右执行，更直观
    val pipeline = addOne andThen double andThen toString
    // 执行顺序: addOne -> double -> toString
    
    println(pipeline(5))  // "Result: 12"  即 (5+1)*2 = 12
    
    // 对比 compose 和 andThen
    val f = addOne
    val g = double
    
    val composed = g compose f    // f 先执行，g 后执行
    val chained = f andThen g     // f 先执行，g 后执行
    
    // 两者结果相同，但 andThen 阅读顺序更自然
    println(composed(10))  // 22
    println(chained(10))   // 22
}

┌─────────────────────────────────────────────────────────────┐
│  compose vs andThen 执行顺序对比                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  compose (从右到左，数学风格):                               │
│  val result = (f compose g compose h)(x)                    │
│                                                             │
│       x ──► h(x) ──► g(h(x)) ──► f(g(h(x)))                │
│            [先]      [中]         [后]                      │
│                                                             │
│  ─────────────────────────────────────────────────────────  │
│                                                             │
│  andThen (从左到右，管道风格):                               │
│  val result = (f andThen g andThen h)(x)                    │
│                                                             │
│       x ──► f(x) ──► g(f(x)) ──► h(g(f(x)))                │
│            [先]      [中]         [后]                      │
│                                                             │
│  推荐: andThen 更符合数据流动的直觉                          │
└─────────────────────────────────────────────────────────────┘

// ═══════════════════════════════════════════════════════════
// 实用工具：组合任意数量的函数
// ═══════════════════════════════════════════════════════════
 
// 组合多个相同类型的函数
fun <T> composeAll(vararg functions: (T) -> T): (T) -> T {
    return { input ->
        functions.foldRight(input) { func, acc -> 
            func(acc)  // 从右到左依次应用
        }
    }
}
 
// 管道式组合（从左到右）
fun <T> pipeline(vararg functions: (T) -> T): (T) -> T {
    return { input ->
        functions.fold(input) { acc, func -> 
            func(acc)  // 从左到右依次应用
        }
    }
}
 
fun main() {
    val trim: (String) -> String = { it.trim() }
    val lowercase: (String) -> String = { it.lowercase() }
    val removeSpaces: (String) -> String = { it.replace(" ", "_") }
    val addPrefix: (String) -> String = { "user_$it" }
    
    // 创建用户名处理管道
    val normalizeUsername = pipeline(trim, lowercase, removeSpaces, addPrefix)
    
    val input = "  John Doe  "
    println(normalizeUsername(input))  // "user_john_doe"
}

// ═══════════════════════════════════════════════════════════
// 实际案例：订单处理管道
// ═══════════════════════════════════════════════════════════
 
data class Order(
    val items: List<String>,
    val subtotal: Double,
    val discount: Double = 0.0,
    val tax: Double = 0.0,
    val total: Double = 0.0,
    val status: String = "created"
)
 
// 定义处理步骤（每个都是纯函数）
val validateOrder: (Order) -> Order = { order ->
    require(order.items.isNotEmpty()) { "Order must have items" }
    require(order.subtotal > 0) { "Subtotal must be positive" }
    order.copy(status = "validated")
}
 
val applyDiscount: (Order) -> Order = { order ->
    val discountAmount = if (order.subtotal > 100) order.subtotal * 0.1 else 0.0
    order.copy(discount = discountAmount, status = "discounted")
}
 
val calculateTax: (Order) -> Order = { order ->
    val taxableAmount = order.subtotal - order.discount
    val taxAmount = taxableAmount * 0.08  // 8% 税率
    order.copy(tax = taxAmount, status = "taxed")
}
 
val calculateTotal: (Order) -> Order = { order ->
    val finalTotal = order.subtotal - order.discount + order.tax
    order.copy(total = finalTotal, status = "completed")
}
 
fun main() {
    // 组合成完整的处理管道
    val processOrder = pipeline(
        validateOrder,
        applyDiscount,
        calculateTax,
        calculateTotal
    )
    
    val order = Order(
        items = listOf("Book", "Pen", "Notebook"),
        subtotal = 150.0
    )
    
    val processed = processOrder(order)
    println(processed)
    // Order(items=[Book, Pen, Notebook], subtotal=150.0, 
    //        discount=15.0, tax=10.8, total=145.8, status=completed)
}

infix fun <A, B, C> ((A) -> B).andThen(other: (B) -> C): (A) -> C = { other(this(it)) }
 
val f: (Int) -> Int = { it + 2 }
val g: (Int) -> Int = { it * 3 }
val h: (Int) -> Int = { it - 1 }
 
val combined = f andThen g andThen h
val result = combined(4)

// ═══════════════════════════════════════════════════════════
// 柯里化的基本概念
// ═══════════════════════════════════════════════════════════
 
// 普通的二元函数
fun add(a: Int, b: Int): Int = a + b
 
// 柯里化版本：返回一个函数
fun addCurried(a: Int): (Int) -> Int = { b -> a + b }
 
// 使用对比
fun main() {
    // 普通调用：一次传入所有参数
    val sum1 = add(3, 5)  // 8
    
    // 柯里化调用：分步传入参数
    val addThree = addCurried(3)  // 得到一个"加3"的函数
    val sum2 = addThree(5)        // 8
    
    // 也可以连续调用
    val sum3 = addCurried(3)(5)   // 8
    
    // 柯里化的威力：轻松创建特化函数
    val addTen = addCurried(10)
    val addHundred = addCurried(100)
    
    println(addTen(5))      // 15
    println(addHundred(5))  // 105
    
    // 可以用于集合操作
    val numbers = listOf(1, 2, 3, 4, 5)
    val plusTen = numbers.map(addTen)  // [11, 12, 13, 14, 15]
}

// ═══════════════════════════════════════════════════════════
// 柯里化的实际价值
// ═══════════════════════════════════════════════════════════
 
// 场景：日志记录器
// 普通版本
fun log(level: String, category: String, message: String) {
    println("[$level][$category] $message")
}
 
// 柯里化版本
fun logCurried(level: String): (String) -> (String) -> Unit {
    return { category ->
        { message ->
            println("[$level][$category] $message")
        }
    }
}
 
fun main() {
    // 普通版本：每次都要传所有参数
    log("ERROR", "Database", "Connection failed")
    log("ERROR", "Database", "Query timeout")
    log("ERROR", "Network", "Request failed")
    
    // 柯里化版本：创建特化的日志函数
    val errorLog = logCurried("ERROR")           // 固定级别
    val dbErrorLog = errorLog("Database")        // 固定级别和类别
    val networkErrorLog = errorLog("Network")    // 另一个特化版本
    
    // 使用特化函数，代码更简洁
    dbErrorLog("Connection failed")
    dbErrorLog("Query timeout")
    networkErrorLog("Request failed")
    
    // 创建更多特化版本
    val infoLog = logCurried("INFO")
    val debugLog = logCurried("DEBUG")
    val apiInfoLog = infoLog("API")
    
    apiInfoLog("Request received")
    apiInfoLog("Response sent")
}

// ═══════════════════════════════════════════════════════════
// 部分应用 vs 柯里化
// ═══════════════════════════════════════════════════════════
 
// 原始三元函数
fun sendEmail(from: String, to: String, subject: String, body: String): String {
    return "From: $from\nTo: $to\nSubject: $subject\n\n$body"
}
 
// 柯里化：严格地每次一个参数
fun sendEmailCurried(from: String): (String) -> (String) -> (String) -> String {
    return { to ->
        { subject ->
            { body ->
                "From: $from\nTo: $to\nSubject: $subject\n\n$body"
            }
        }
    }
}
 
// 部分应用：可以一次固定多个参数
fun sendEmailFrom(from: String): (String, String, String) -> String {
    return { to, subject, body ->
        sendEmail(from, to, subject, body)
    }
}
 
fun sendEmailFromTo(from: String, to: String): (String, String) -> String {
    return { subject, body ->
        sendEmail(from, to, subject, body)
    }
}
 
fun main() {
    // 柯里化使用
    val fromAlice = sendEmailCurried("alice@example.com")
    val aliceToBob = fromAlice("bob@example.com")
    val greeting = aliceToBob("Hello")
    val email1 = greeting("How are you?")
    
    // 部分应用使用：更灵活
    val companyEmail = sendEmailFrom("noreply@company.com")
    val email2 = companyEmail("user@example.com", "Welcome", "Welcome to our service!")
    
    val aliceToBobDirect = sendEmailFromTo("alice@example.com", "bob@example.com")
    val email3 = aliceToBobDirect("Meeting", "Let's meet at 3pm")
}

// ═══════════════════════════════════════════════════════════
// 手动实现柯里化工具函数
// ═══════════════════════════════════════════════════════════
 
// 二元函数柯里化
fun <A, B, R> ((A, B) -> R).curried(): (A) -> (B) -> R {
    return { a: A ->
        { b: B ->
            this(a, b)  // this 指向原函数
        }
    }
}
 
// 三元函数柯里化
fun <A, B, C, R> ((A, B, C) -> R).curried(): (A) -> (B) -> (C) -> R {
    return { a: A ->
        { b: B ->
            { c: C ->
                this(a, b, c)
            }
        }
    }
}
 
// 反柯里化：将柯里化函数转回普通函数
fun <A, B, R> ((A) -> (B) -> R).uncurried(): (A, B) -> R {
    return { a: A, b: B ->
        this(a)(b)
    }
}
 
fun main() {
    // 定义普通函数
    val multiply: (Int, Int) -> Int = { a, b -> a * b }
    val formatPrice: (String, Double, Int) -> String = { currency, price, quantity ->
        "$currency${price * quantity}"
    }
    
    // 柯里化
    val multiplyCurried = multiply.curried()
    val formatPriceCurried = formatPrice.curried()
    
    // 使用柯里化版本
    val double = multiplyCurried(2)
    val triple = multiplyCurried(3)
    
    println(double(5))   // 10
    println(triple(5))   // 15
    
    // 三元函数柯里化使用
    val usdFormatter = formatPriceCurried("$")
    val usd99 = usdFormatter(99.0)
    
    println(usd99(1))    // $99.0
    println(usd99(3))    // $297.0
    
    // 反柯里化
    val multiplyUncurried = multiplyCurried.uncurried()
    println(multiplyUncurried(4, 5))  // 20
}

// ═══════════════════════════════════════════════════════════
// 实际应用：配置化的验证器
// ═══════════════════════════════════════════════════════════
 
// 通用验证函数
val validateLength: (Int, Int, String) -> Boolean = { min, max, value ->
    value.length in min..max
}
 
val validateRange: (Int, Int, Int) -> Boolean = { min, max, value ->
    value in min..max
}
 
val validatePattern: (String, String) -> Boolean = { pattern, value ->
    Regex(pattern).matches(value)
}
 
// 柯里化扩展
fun <A, B, C, R> ((A, B, C) -> R).curried() = { a: A -> { b: B -> { c: C -> this(a, b, c) } } }
fun <A, B, R> ((A, B) -> R).curried() = { a: A -> { b: B -> this(a, b) } }
 
fun main() {
    // 创建特化验证器
    val validateUsername = validateLength.curried()(3)(20)      // 3-20字符
    val validatePassword = validateLength.curried()(8)(128)     // 8-128字符
    val validateAge = validateRange.curried()(0)(150)           // 0-150岁
    val validateEmail = validatePattern.curried()("^[\\w.-]+@[\\w.-]+\\.\\w+$")
    
    // 使用验证器
    println(validateUsername("alice"))           // true
    println(validateUsername("ab"))              // false (太短)
    println(validatePassword("12345678"))        // true
    println(validateAge(25))                     // true
    println(validateEmail("test@example.com"))   // true
    
    // 组合验证
    data class UserInput(val username: String, val password: String, val age: Int)
    
    fun validateUser(input: UserInput): Boolean {
        return validateUsername(input.username) &&
               validatePassword(input.password) &&
               validateAge(input.age)
    }
    
    val user = UserInput("alice", "securepass123", 25)
    println(validateUser(user))  // true
}

// ═══════════════════════════════════════════════════════════
// 柯里化 + 函数组合 = 强大的抽象能力
// ═══════════════════════════════════════════════════════════
 
// 柯里化的 map 函数
val mapCurried: ((Int) -> Int) -> (List<Int>) -> List<Int> = { transform ->
    { list -> list.map(transform) }
}
 
// 柯里化的 filter 函数
val filterCurried: ((Int) -> Boolean) -> (List<Int>) -> List<Int> = { predicate ->
    { list -> list.filter(predicate) }
}
 
// andThen 组合
infix fun <A, B, C> ((A) -> B).andThen(other: (B) -> C): (A) -> C = { other(this(it)) }
 
fun main() {
    // 创建特化的列表操作
    val doubleAll = mapCurried { it * 2 }
    val keepPositive = filterCurried { it > 0 }
    val addTenToAll = mapCurried { it + 10 }
    
    // 组合成处理管道
    val processNumbers = keepPositive andThen doubleAll andThen addTenToAll
    
    val numbers = listOf(-5, 3, -2, 8, 0, 4)
    val result = processNumbers(numbers)
    
    println(result)  // [16, 26, 18]
    // 过程: [-5,3,-2,8,0,4] -> [3,8,4] -> [6,16,8] -> [16,26,18]
}

fun <A, B, C, R> ((A, B, C) -> R).curried() = { a: A -> { b: B -> { c: C -> this(a, b, c) } } }
 
val calculate: (Int, Int, Int) -> Int = { a, b, c -> (a + b) * c }
val step1 = calculate.curried()(10)
val step2 = step1(5)
val result = step2(2)

// ═══════════════════════════════════════════════════════════
// 偏函数应用的基本概念
// ═══════════════════════════════════════════════════════════
 
// 原始函数：计算商品总价
fun calculatePrice(
    basePrice: Double,    // 基础价格
    taxRate: Double,      // 税率
    discount: Double,     // 折扣
    quantity: Int         // 数量
): Double {
    val priceAfterDiscount = basePrice * (1 - discount)  // 应用折扣
    val priceWithTax = priceAfterDiscount * (1 + taxRate) // 加税
    return priceWithTax * quantity                        // 乘以数量
}
 
// 偏函数应用：固定税率，返回新函数
fun withTaxRate(taxRate: Double): (Double, Double, Int) -> Double {
    return { basePrice, discount, quantity ->
        calculatePrice(basePrice, taxRate, discount, quantity)
    }
}
 
// 偏函数应用：固定税率和折扣
fun withTaxAndDiscount(taxRate: Double, discount: Double): (Double, Int) -> Double {
    return { basePrice, quantity ->
        calculatePrice(basePrice, taxRate, discount, quantity)
    }
}
 
fun main() {
    // 创建特化版本：美国税率 8%
    val usaPricing = withTaxRate(0.08)
    
    // 创建更特化版本：美国税率 + VIP 20% 折扣
    val usaVipPricing = withTaxAndDiscount(0.08, 0.20)
    
    // 使用特化函数
    val price1 = usaPricing(100.0, 0.0, 2)      // 无折扣，2件
    val price2 = usaVipPricing(100.0, 3)         // VIP价，3件
    
    println("普通价格: $$price1")   // 普通价格: $216.0
    println("VIP价格: $$price2")    // VIP价格: $259.2
}