// Kotlin 的气质：空安全 + 一切皆表达式
data class User(val name: String, val email: String?)

fun domain(user: User?): String {
    val email = user?.email ?: return "无邮箱"  // 安全调用 + Elvis
    return email.substringAfter("@")
}

println(domain(User("Alice", "alice@corp.com")))  // corp.com

// ① Kotlin Playground —— play.kotlinlang.org，粘贴、点运行
//    零安装；不能加第三方依赖，不能断点调试

// ② 命令行 kotlinc
//    java -version      → 先确认 JDK 就位（要 17+）
//    解压 kotlin-compiler-2.4.10.zip，把其中的 bin/ 加进 PATH
//    kotlinc -version   → info: kotlinc-jvm 2.4.10 (JRE 25.0.1+8-LTS-27)

// ③ IntelliJ IDEA Community / Android Studio
//    New Project → Kotlin，构建系统选 Gradle（Kotlin DSL）
//    src/main/kotlin/Main.kt 里已经有一个 fun main()，点绿三角即可

// 三条路的共同前提：编译产物是 JVM 字节码，要有 JVM 才能跑

// hello.kt
fun main() {                    // ① 顶层函数，不属于任何类
    val name = "Kotlin"          // ② 行尾没有分号
    println("Hello, $name!")   // ③ println 来自 kotlin.io，默认导入
}

// ---- 用 javap 看编译器到底造了什么 ----
//   kotlinc hello.kt -d out
//   javap -p -cp out HelloKt
// 输出：
//   public final class HelloKt {
//     public static final void main();              ← 你写的那个
//     public static void main(java.lang.String[]);  ← 编译器合成的转发器
//   }
// 类是编译器按文件名造的，那个转发器是给 java 命令找入口用的；
// 自己写成 fun main(args: Array<String>) 时，就只有一个 main 了。

// ===== 编译期：带 文件:行:列 前缀，不会产出任何东西 =====

fun find(): String? = null
val s: String = find()
// e5.kt:3:19: error: initializer type mismatch: expected 'String', actual 'String?'.

val t: String? = find()
println(t.length)
// e6.kt:4:14: error: only safe (?.) or non-null asserted (!!.) calls are
//            allowed on a nullable receiver of type 'String?'.

// ---- unresolved reference 的三种成因 ----
printn("typo")                // 拼错
// e2.kt:2:5: error: unresolved reference 'printn'.
File("a.txt")                 // 忘了 import java.io.File
// e8.kt:2:13: error: unresolved reference 'File'.
import kotlinx.coroutines.runBlocking  // 没加依赖
// e4.kt:1:8: error: unresolved reference 'kotlinx'.   ← 画在最外层包名上

// ===== 运行期：没有行列前缀，换成 Exception in thread + 栈帧 =====

val u: String = find()!!
// Exception in thread "main" java.lang.NullPointerException
//     at R1Kt.main(r1.kt:4)     ← 注意不是 KotlinNullPointerException

val name = "Kotlin"      // 类型推断为 String
var count = 0              // 可重新赋值
count++                       // ✅ 合法
// name = "Java"            // ❌ val cannot be reassigned

// —— val 锁的是引用，不是对象（输出 [1, 2, 3, 4]）——
val list = mutableListOf(1, 2, 3)
list.add(4)                  // ✅ 引用没变，内容变了
println(list)                  // [1, 2, 3, 4]
// list = mutableListOf()   // ❌ val cannot be reassigned

// 想连内容一起管住：换只读类型（只读 ≠ 不可变，见集合章）
val ro: List<Int> = listOf(1, 2, 3)
// ro.add(4)                // ❌ List 上根本没有 add

// 显式类型声明（public API 建议写出来）
val pi: Double = 3.14159
val msg: String = "Hello"

val i: Int = 42
val l: Long = i.toLong()     // 必须显式转换
val d: Double = 3.14
val f: Float = 3.14f
val b: Boolean = true
val c: Char = 'K'

// 数字字面量的写法
val hex = 0xFF              // 十六进制
val bin = 0b1010            // 二进制
val big = 1_000_000         // 下划线只是给人看的

// 字面量按期望类型静态检查：42 直接赋给 Long 合法
val x: Long = 42

// 但变量之间不会隐式拓宽
val n: Int = 42
// val wide: Long = n
//   ❌ initializer type mismatch: expected 'Long', actual 'Int'.
val wide: Long = n.toLong()  // ✅

// —— 装箱缓存：可空数字比引用会出错——
val p: Int? = 127;  val q: Int? = 127
val r: Int? = 128;  val s: Int? = 128
println(p == q)                 // true
println(r == s)                 // true —— 用 == 永远对
// println(p === q)  ⚠️ 警告：identity equality for arguments
//                     of types 'Int?' and 'Int?' is prohibited.
println((p as Any?) === (q as Any?))  // true （127 在缓存里）
println((r as Any?) === (s as Any?))  // false（128 不在）

// —— 无符号类型——
val u: UInt = 4_000_000_000u   // Int 装不下，UInt 可以
println(UInt.MAX_VALUE)         // 4294967295
println(0u - 1u)                // 4294967295（回绕，不报错）
println(u.toInt())              // -294967296（同样的 bit，换个解释）

// —— 溢出与精度：静默发生，不抛异常——
println(Int.MAX_VALUE + 1)      // -2147483648
println(0.1 + 0.2)              // 0.30000000000000004
println(3.9.toInt())             // 3  —— 截断，不是四舍五入
println((-3.9).toInt())          // -3 —— 向零截断

val name = "Kotlin"
val price = 5

// —— 插值的两种形态 ——
println("Hello, $name!")          // 标识符直接跟
println("Length: ${name.length}")  // 表达式必须加 {}
println("$name.length")           // ⚠️ 输出 "Kotlin.length"

// —— 输出字面的 $（两种写法，都是 cost: $5）——
println("cost: \$$price")         // 普通串：反斜杠转义
println("""cost: ${'$'}$price""")  // 原始串：插一个 '$' 字符

// —— 原始字符串 + trimIndent：去公共缩进，并丢掉首尾空行 ——
val json = """
    {
      "name": "$name"
    }
""".trimIndent()
// 结果（3 行，无前导空格）：
// {
//   "name": "Kotlin"
// }

// —— trimMargin：按 | 裁剪，缩进自己控制 ——
val sql = """
    |SELECT *
    |FROM users
    |WHERE active = true
""".trimMargin()

// ⚠️ 混用的结果：竖线会被原样留下
val oops = """
    |SELECT *
    |FROM users
""".trimIndent()
// oops == "|SELECT *\n|FROM users"

// —— 编译期常量：顶层 / object / companion object ——
const val MAX_RETRY = 3
const val API_URL = "https://api.example.com"
const val FULL = API_URL + "/v1"   // ✅ const 之间可拼接

// ❌ const val d = Date()
//   const 'val' has type 'Date'. Only primitive types and 'String' are allowed.

class Holder {
    // ❌ const val INSIDE = 1
    //   const 'val' is only allowed on top level, in named objects,
    //   in companion objects or companion blocks.
    companion object {
        const val INSIDE = 1       // ✅ 放这儿就行
    }
}

// —— 类型别名：只换写法，不换类型 ——
typealias UserMap = Map<String, List<String>>
typealias Predicate<T> = (T) -> Boolean
typealias UserId = String

fun load(id: UserId) { /* ... */ }
val orderNo: String = "ORD-1"
load(orderNo)   // ⚠️ 编译通过！别名拦不住传错

fun filterUsers(users: UserMap): UserMap =
    users.filterValues { it.isNotEmpty() }

// —— 推断一次定死 ——
var x = 1            // 推断为 Int
// x = "hello"
//   ❌ assignment type mismatch: actual type is 'String',
//      but 'Int' was expected.

var y = null         // 推断为 Nothing?（唯一的值就是 null）
// y = "s"      ❌ ... but 'Nothing?' was expected.
var ok: String? = null  // ✅ 这才是你想要的

// —— 右边没线索时，推断不出来 ——
// val empty = listOf()
//   ❌ cannot infer type for type parameter 'T'. Specify it explicitly.
val empty = listOf<String>()          // ✅ 写死类型实参
val empty2: List<String> = listOf()   // ✅ 或者由左边提供期望类型

// —— 递归 + 表达式体：必须写返回类型 ——
// fun fact(n: Int) = if (n <= 1) 1 else n * fact(n - 1)
//   ❌ type checking has run into a recursive problem.
fun fact(n: Int): Int = if (n <= 1) 1 else n * fact(n - 1)

// —— lambda 参数：有期望类型才能省 ——
val lens = listOf("a", "bb").map { it.length }  // it: String，由 map 决定
val inc: (Int) -> Int = { it + 1 }            // 左边给了期望类型
val inc2 = { n: Int -> n + 1 }                 // 没期望类型 → 自己标注

// —— TODO() 返回 Nothing，能顶替任何类型 ——
fun area(): Double = TODO("等几何库接进来")
// 调用时抛：
//   kotlin.NotImplementedError: An operation is not implemented: 等几何库接进来

// —— public API：把类型写出来，别让实现细节变成契约 ——
fun activeIds(): List<Long> = mutableListOf(1L, 2L)  // 返回类型是 List，不是 MutableList

// —— if 是表达式：Kotlin 的「三元」——
val max = if (a > b) a else b

// 分支是块时，块的最后一个表达式就是值
val level = if (score >= 60) {
    println("及格")
    "pass"            // ← 这就是 level 的值，不写 return
} else "fail"

// —— when：带主体的三种匹配 ——
val desc = when (code) {
    200 -> "OK"
    301, 302 -> "Redirect"          // 逗号 = 或
    in 400..499 -> "Client Error"   // 范围
    else -> "Unknown"
}

fun classify(x: Any): String = when (x) {
    is String -> "String(${x.length})"  // 命中后 x 自动是 String
    in 1..9 -> "small int"
    !is Int -> "not int"
    else -> "big int"
}

// —— when 无主体：替代 if-else 链 ——
val label = when {
    score >= 90 -> "A"
    score >= 80 -> "B"
    else -> "F"
}

// —— guard conditions（2.4.10 无需 opt-in）——
sealed interface Shape
data class Circle(val r: Double) : Shape
data class Rect(val w: Double, val h: Double) : Shape

fun describe(s: Shape): String = when (s) {
    is Circle if s.r > 10 -> "big circle"   // 带 guard 的要写在上面
    is Circle -> "small circle"
    is Rect if s.w == s.h -> "square"
    is Rect -> "rect"
}                        // ← sealed 覆盖全，无需 else（通过）

// —— 范围（结果为输出）——
for (i in 1..5) print(i)          // 12345（闭区间）
for (i in 1..<5) print(i)         // 1234（半开，等价 1 until 5）
for (i in 5 downTo 1) print(i)   // 54321
println((1..10 step 3).toList())   // [1, 4, 7, 10]
println((5..1).toList())            // [] ← 空！倒序必须用 downTo
println(('a'..'e').toList())        // [a, b, c, d, e]
println(0.5 in 0.0..1.0)           // true（浮点范围只能这么用）

// —— 遍历下标：用 indices 或 ..< ，别用 ..size ——
val list = listOf("a", "b", "c")
for (i in list.indices) print(list[i])   // ✅ abc
for (i in 0..<list.size) print(list[i]) // ✅ abc
// for (i in 0..list.size) print(list[i])
//   ❌ 抛 java.lang.ArrayIndexOutOfBoundsException:
//      Index 3 out of bounds for length 3

// 大多数时候连下标都不需要
for (s in list) print(s)
for ((i, s) in list.withIndex()) println("$i: $s")

// —— 没有 C 风格 for，重复固定次数用 repeat ——
repeat(3) { i -> print(i) }        // 012

// —— while / do-while 照旧 ——
var n = 3
while (n > 0) { print(n); n-- }
do { print(n) } while (n > 0)

// —— 标签跳转：定义处 outer@，使用处 break@outer ——
outer@ for (i in 1..3) {
    for (j in 1..3) {
        if (i == 2 && j == 2) break@outer
        print("$i$j ")
    }
}                                     // 11 12 13 21

// —— 非 inline 的 lambda 里不能裸 return ——
fun <T> List<T>.myForEach(action: (T) -> Unit) {
    for (e in this) action(e)
}
fun bad(xs: List<Int>) {
    xs.myForEach {
        // if (it == 2) return   ❌ 'return' is prohibited here.
    }
}

// —— inline 的 lambda 里可以，而且是「非局部返回」——
inline fun <T> myInline(xs: List<T>, f: (T) -> Unit) { for (x in xs) f(x) }

fun find2(xs: List<Int>): String {
    myInline(xs) { if (it == 2) return "早退" }  // 从 find2 返回！
    return "跑完了"
}
// find2(listOf(1,2,3)) == "早退"；find2(listOf(9)) == "跑完了"

// —— 想「跳过这一项」：带标签返回 ——
val sb = StringBuilder()
listOf(1, 2, 3).forEach {
    if (it == 2) return@forEach     // = continue，不是退出函数
    sb.append(it)
}
println(sb)                          // 13

// —— Nothing：没有实例，因此是所有类型的子类型 ——
fun fail(msg: String): Nothing = throw IllegalStateException(msg)

val s: String = if (list.isEmpty()) fail("空的") else "ok"
// 编译器知道 fail() 不会返回 → 整个 if 的类型仍是 String

// 标准库里返回 Nothing 的三个常客（异常类型均为）
// TODO("later") → kotlin.NotImplementedError: An operation is not implemented: later
// error("boom") → java.lang.IllegalStateException: boom
// throw ...     → 本身就是 Nothing 类型的表达式

// —— Elvis 右侧放 return / throw：守卫写法 ——
fun firstOrDefault(xs: List<Int>): Int {
    val v = xs.firstOrNull() ?: return -1   // 这行之后 v 是 Int，不是 Int?
    return v
}
fun load(map: Map<String, String>): String =
    map["key"] ?: throw IllegalArgumentException("missing key")
// load(emptyMap()) 抛 java.lang.IllegalArgumentException: missing key

// —— 控制台输出 ——
print("不换行 ")
println("自动换行")
val user = "Kotlin"
println("Hello, $user!")      // 格式化直接用字符串模板
System.err.println("出错了")  // 错误信息走 stderr，与标准输出分流

// —— 读一行 + 转数字：先用最朴素的形态 ——
print("你的名字: ")
val name = readln()               // EOF 会抛异常，健壮版见空安全章
print("年龄: ")
val age = readln().trim().toInt() // "abc" 会抛 NumberFormatException
val next = age + 1
println("$name 明年 $next 岁")

// —— 逐行读到 EOF：readLine() 到头返回 null ——
var line = readLine()
while (line != null) {
    println("读到: $line")
    line = readLine()
}

// —— 文件：小文件一步到位（文件顶部需 import java.io.File）——
val f = File("notes.txt")
f.writeText("第一行\n")      // 覆盖写入
f.appendText("第二行\n")     // 追加
println(f.readText())         // 一次读回整个文件
for (l in f.readLines()) {    // readLines(): List<String>，for-in 遍历
    println(l)
}

// 跨平台拼路径：别手写分隔符
val nested = File(File("data"), "notes.txt")

// —— 块体：必须写返回类型 ——
fun greet(name: String): String {
    val t = name.trim()
    return "Hello, $t!"
}

// —— 表达式体：可以省返回类型（public API 仍建议写）——
fun shout(name: String) = "HELLO, ${name.uppercase()}!"
fun shout2(name: String): String = "HELLO, ${name.uppercase()}!"

// ❌ 递归 + 表达式体 + 省返回类型：
//   type checking has run into a recursive problem.
fun fact(n: Int): Int = if (n <= 1) 1 else n * fact(n - 1)

// —— 默认参数 + 命名实参 ——
fun connect(
    host: String = "localhost",
    port: Int = 8080,
    secure: Boolean = false
) = "$host:$port secure=$secure"

connect()                            // localhost:8080 secure=false
connect(port = 3000)                 // localhost:3000 secure=false
connect(secure = true, port = 443)  // localhost:443  secure=true（可乱序）

// —— 默认值是表达式：每次调用求值，且能引用前面的参数——
var calls = 0
fun nextId(): Int { calls++; return calls }
fun mk(a: Int, b: Int = a * 2, id: Int = nextId()) = "a=$a b=$b id=$id"

println(mk(3))          // a=3 b=6 id=1
println(mk(3))          // a=3 b=6 id=2 ← id 每次重新算
println(mk(3, 99))      // a=3 b=99 id=3

// —— vararg：函数内部是数组 ——
fun sum(vararg nums: Int): Int = nums.sum()
println(sum(1, 2, 3))     // 6
println(sum())            // 0 ← 传 0 个也合法

fun varargType(vararg n: Int) = n::class.java.name
println(varargType(1, 2))  // [I  （就是 int[]）

// —— 展开操作符 * ——
val arr = intArrayOf(4, 5, 6)
println(sum(*arr))         // 15
println(sum(1, *arr, 9))   // 可以和普通实参混写

fun takesStrings(vararg s: String) = s.size
val names = arrayOf("a", "b")
println(takesStrings(*names))  // 2
// takesStrings(names)
//   ❌ argument type mismatch: actual type is 'Array<String>',
//      but 'String' was expected.

// vararg 不必在最后，后面的参数用命名实参传
fun join(vararg parts: String, sep: String = "-") = parts.joinToString(sep)
println(join("a", "b", sep = "/"))   // a/b

// —— Unit 是真实的单例对象——
println(Unit::class.java.name)   // kotlin.Unit
println(Unit === Unit)           // true
val u: Any = println("x")        // println 返回 Unit
println(u === Unit)              // true ← 真的是那个单例

// 两种写法等价
fun log1(msg: String): Unit { println(msg) }
fun log2(msg: String) { println(msg) }

// —— Nothing：永不正常返回 ——
fun fail(msg: String): Nothing = throw IllegalStateException(msg)
val v = map[key] ?: fail("Key not found")  // v 是非空类型

// ============ 顶层函数（文件名 funcs2.kt）============
fun topLevel(x: Int): Int = x * 2

// javap -p -cp out Funcs2Kt 输出（节选）：
//   public final class Funcs2Kt {
//     public static final int topLevel(int);
//     ...
//   }
// Java 侧调用：Funcs2Kt.topLevel(21)
// 想改类名：文件第一行写 @file:JvmName("Utils") → Utils.topLevel(21)

// ============ 局部函数：捕获外层变量 ============
fun report(items: List<String>): String {
    val sb = StringBuilder()
    var count = 0
    fun emit(tag: String) {   // 直接用外层的 sb 和 count
        count++
        sb.append("[$tag]")
    }
    for (i in items) emit(i)
    return "$sb count=$count"
}
println(report(listOf("a", "b")))   // [a][b] count=2

// javap 里它长这样：
//   private static final void report$emit(
//       kotlin.jvm.internal.Ref$IntRef,   ← 被修改的 var count 装进了盒子
//       java.lang.StringBuilder,          ← 捕获的 sb 变成了参数
//       java.lang.String);

// 局部函数也能递归
fun demo() {
    fun fib(k: Int): Int = if (k < 2) k else fib(k - 1) + fib(k - 2)
    println(fib(10))     // 55
}

// ============ infix ============
infix fun Int.pow2(times: Int): Int {          // ✅ 扩展函数 + 一个参数
    var r = 1; repeat(times) { r *= this }; return r
}
println(2 pow2 10)      // 1024，等价于 2.pow2(10)

// ❌ infix fun bad(a: Int, b: Int) = a + b        （顶层普通函数）
// ❌ infix fun Int.bad(vararg xs: Int) = 0        （vararg）
//   两者报错都是：'infix' modifier is inapplicable to this function.

class Box(val v: Int) {
    infix fun combine(o: Box) = Box(v + o.v)
    fun test(o: Box) = this combine o   // ✅ this 不能省
    // fun bad(o: Box) = combine o
    //   ❌ function invocation 'combine(...)' expected.
}

// ⚠️ 中缀调用的优先级低于算术运算符：
//    2 pow2 1 + 1    → 4  （= 2 pow2 (1 + 1)）
//    (2 pow2 1) + 1  → 3  （想要这个就得自己加括号）

// ============ 函数引用 ============
fun greet(name: String) = "Hello, $name!"
class Greeter(val prefix: String) {
    fun hi(name: String) = "$prefix $name"
}

val f: (String) -> String = ::greet          // 顶层函数引用
println(f("a"))                             // Hello, a!
println(::greet.name)                       // greet

val g = Greeter(">>")
val bound: (String) -> String = g::hi       // 绑定引用（接收者定死）
println(bound("b"))                         // >> b

val unbound: (Greeter, String) -> String = Greeter::hi
println(unbound(g, "c"))                    // >> c（接收者成了第一个参数）

// 替代「只是转发」的 lambda
println(listOf("x", "yy").map(String::length))  // [1, 2]

// ============ ::class ============
println("s"::class.java)          // class java.lang.String
println(String::class.qualifiedName) // kotlin.String
println("s"::class)
// （无 kotlin-reflect 依赖时）：
//   class java.lang.String (Kotlin reflection is not available)

// ============ Kotlin 侧 ============
fun connect(host: String = "localhost", port: Int = 8080, secure: Boolean = false) =
    "$host:$port secure=$secure"

@JvmOverloads
fun connect2(host: String = "localhost", port: Int = 8080, secure: Boolean = false) =
    "$host:$port secure=$secure"

// ============ javap -p -cp out Funcs2Kt 输出（节选）============
// public static final java.lang.String connect(java.lang.String, int, boolean);
// public static java.lang.String connect$default(java.lang.String, int,
//                                boolean, int, java.lang.Object);
//   ↑ 只有这两个 —— Java 侧必须把三个参数全传
//
// public static final java.lang.String connect2(java.lang.String, int, boolean);
// public static java.lang.String connect2$default(...);
// public static final java.lang.String connect2(java.lang.String, int);
// public static final java.lang.String connect2(java.lang.String);
// public static final java.lang.String connect2();
//   ↑ 五个 —— 后三个才是 Java 能享受到的「默认参数」

// ============ Java 侧（javac）============
// Funcs2Kt.connect2();              ✅ 编译通过
// Funcs2Kt.connect2("h");           ✅ 编译通过
// Funcs2Kt.connect("h", 1, false);  ✅ 全传就行
// Funcs2Kt.connect();               ❌
//   error: method connect in class Funcs2Kt cannot be applied to given types;
//     required: String,int,boolean
//     found:    no arguments

// ============ 构造函数上的写法 ============
class Conn @JvmOverloads constructor(
    val host: String = "localhost",
    val port: Int = 8080
)   // 注解在 constructor 前，且这时 constructor 关键字不能省

var name: String = "Kotlin"  // 非空，name = null 编译不过
var nick: String? = null      // 可空类型

// 安全调用 ?.（null 时整个表达式短路成 null）
val len: Int? = nick?.length   // null（不是 0！类型是 Int? 不是 Int）

// Elvis ?:（null 时用右边的值）
val display = nick ?: "匿名"   // "匿名"，类型是 String（非空）

// 链式安全调用：任一环为 null 就整条短路
val city = user?.address?.city ?: "未知"

// Elvis + return：前置校验的惯用写法，代码不用往右缩进
fun handle(params: Map<String, String>) {
    val id = params["id"] ?: return          // 没有就直接退出
    val n  = id.toIntOrNull() ?: error("id 不是数字")
    // 到这里 id 是 String、n 是 Int，都非空
}

// ?.let：对非空值执行一整段逻辑
nick?.let { n ->
    println("昵称长度 ${n.length}")
    save(n)
}

// 断言：三种强度，异常类型不同（均已）
val a = requireNotNull(nick) { "nick 必填" }  // IllegalArgumentException: nick 必填
val b = checkNotNull(nick)                    // IllegalStateException: Required value was null.
val c = nick!!.length                        // java.lang.NullPointerException（message 为 null）

// 实战：安全读取输入（兑现 03 章 I/O 的预告）
val port = readlnOrNull()?.toIntOrNull() ?: 8080  // EOF 或非数字都兜底

// 智能转换：is 之后直接当目标类型用
fun describe(obj: Any): String = when (obj) {
    is String     -> "字符串，长 ${obj.length}"   // obj 已是 String
    is Int        -> "整数 ${obj + 1}"
    is List<*>    -> "列表，${obj.size} 项"
    else          -> "未知"
}

// 安全转换 as?：转不动返回 null，不抛 ClassCastException
val s: String = obj as? String ?: "不是字符串"

class Box {
    var v: String? = null              // 可变属性
    val custom: String? get() = compute()  // 自定义 getter
    val stable: String? = "hi"        // 普通 val（有幕后字段）
}

fun f(b: Box) {
    if (b.v != null) b.v.length          // ❌ mutable property that could be mutated concurrently
    if (b.custom != null) b.custom.length // ❌ property that has an open or custom getter
    if (b.stable != null) b.stable.length // ✅ 普通 val，智能转换成立

    // 解法一：先用局部 val 接住（快照）
    val v = b.v
    if (v != null) println(v.length)     // ✅

    // 解法二：?.let —— 值是被传进 lambda 的，不存在「再读一次」的问题
    b.v?.let { println(it.length) }       // ✅
}

// lateinit：非空但构造时没法赋值
class UserTest {
    lateinit var service: UserService

    fun setUp() { service = UserService() }

    fun check() {
        if (::service.isInitialized) println(service)   // 只能在类内部这么问
    }
}
// 未初始化就读，抛：
//   kotlin.UninitializedPropertyAccessException:
//   lateinit property service has not been initialized

// ── Java 侧（没有任何可空性注解）───────────────
// public class Legacy {
//     public static String find(String key) { return null; }
// }

// ── Kotlin 侧 ────────────────────────────────
// 编译器完全不拦，因为 find 的返回类型是平台类型 String!
val name: String = Legacy.find("user")
// 运行时
//   Exception in thread "main" java.lang.NullPointerException:
//       find(...) must not be null
//   at MainKt.main(main.kt:3)   ← 崩在赋值这一行，不是使用它的那一行

// 同一个调用，也允许当可空用——编译器一视同仁，不给任何提示
val safe: String? = Legacy.find("user")
println(safe?.length ?: 0)              // 这才是对的写法

// 想看平台类型长什么样？故意写错类型，让编译器打印出来：
val wrong: Int = Legacy.find("k")
//   error: initializer type mismatch: expected 'Int', actual 'String!'.
val wrong2: Int = Legacy.tags()
//   error: initializer type mismatch: expected 'Int',
//          actual '(Mutable)List<String!>!'.

// ── 加了注解的 Java 侧 ────────────────────────
// @Nullable public static String find(String key) { return null; }
val n2: String = Legacy2.find("k")
//   error: initializer type mismatch: expected 'String', actual 'String?'.
//   ✅ 同一个 bug，从运行时崩溃变成编译期错误

// ── 边界封装：让缺口只存在一层 ─────────────────
object LegacyGateway {
    // 进来的一律显式标可空，后面全是 Kotlin 的地盘
    fun find(key: String): String? = Legacy.find(key)
}

// ── 第一层：设计成不会有 null ─────────────────
// ❌ 可选参数用可空类型
fun connect(host: String, timeout: Int?) {
    val t = timeout ?: 30            // 每个实现里都要兜一次底
}
// ✅ 默认参数
fun connect(host: String, timeout: Int = 30) { /* t 一定有值 */ }

// ❌ 「没有结果」返回可空集合
fun search(q: String): List<Item>? = null
search("kt")?.forEach { /* 调用方被迫处理两种「空」*/ }
// ✅ 空集合就是「没有」
fun search2(q: String): List<Item> = emptyList()
for (i in search2("kt")) { /* 空就是不进循环，天然正确 */ }

// ── 第二层：失败原因不止一种时，别用 null ────────
// ❌ 三种失败压成一个 null，调用方无从判断
fun load(path: String): Config? = null

// ✅ 用 sealed 把原因带出来（详见 13 章）
sealed interface LoadResult {
    data class Ok(val cfg: Config) : LoadResult
    data class NotFound(val path: String) : LoadResult
    data class Malformed(val line: Int) : LoadResult
}

// ✅ 或者用标准库的 Result（只关心成功/失败时够用）
val cfg = runCatching { parse(text) }
    .getOrElse { Config.default() }

// ── 第三层：?.let 与 if 的取舍 ────────────────
// ✅ 单值、无 else：let 最顺
nick?.let { render(it); track(it) }

// ⚠️ let ?: 的陷阱——lambda 返回 null 时右边也会执行
val s: String? = "x"
val r = s?.let { null } ?: "fallback"   // r == "fallback"，尽管 s 非空

// ✅ 有 else 分支就老实用 if
if (s != null) render(s) else renderEmpty()

// ❌ 多个可空值嵌套 let：两层已难读
a?.let { x -> b?.let { y -> combine(x, y) } }
// ✅ 局部变量 + 条件判断，或提前退出
if (a != null && b != null) combine(a, b)
// ✅ 函数里最清爽的写法：逐个剥掉
fun go(a: String?, b: String?): String {
    val x = a ?: return "缺 a"
    val y = b ?: return "缺 b"
    return combine(x, y)          // 主干上全是非空值
}

// ── 没有受检异常 ──────────────────────────────
// Java 侧：public static String read() throws IOException
println(Throwy.read())     // ✅ 不写 try 也编译通过（Java 里这样写不给编译）

// ── try 是表达式 ──────────────────────────────
val n: Int = try {
    input.toInt()
} catch (e: NumberFormatException) {
    -1                              // 失败时整个表达式取 -1
} finally {
    println("收尾")                 // 照常执行，但不影响 n 的值
}

// 同一件事，标准库写法更短更清楚 —— 优先用这个
val n2 = input.toIntOrNull() ?: -1

// ── 主动抛出 ─────────────────────────────────
fun divide(a: Int, b: Int): Int {
    require(b != 0) { "除数不能为 0" }   // IllegalArgumentException
    return a / b
}
// require → IllegalArgumentException（参数不对，调用方的错）
// check / error → IllegalStateException（状态不对，自己的错）

// ── use：Kotlin 的 try-with-resources ─────────
val text = File("a.txt").bufferedReader().use { reader ->
    reader.readText()             // 块的值就是 use 的值
}                                    // 到这里 reader 一定已关闭（正常或异常都关）

// 等价的手写版本，样板明显更多
val reader = File("a.txt").bufferedReader()
val text2 = try { reader.readText() } finally { reader.close() }

// ── 把异常包成值：runCatching（详见 13 章）──
val r: Result<Int> = runCatching { input.toInt() }
println(r.getOrDefault(0))

// 主构造器写在类头，参数前加 val/var 就直接成为属性
class User(
    val name: String,              // 只读属性
    var age: Int,                   // 可变属性
    val role: String = "user"      // 默认值
) {
    // ↓ 属性初始化器和 init 块按书写顺序交替执行
    val slug = name.lowercase()      // ① 
    init { require(age > 0) { "年龄必须大于 0" } }   // ②
    val label = "$slug#$age"          // ③ 能用 slug，因为它写在上面
    init { println(label) }            // ④

    // 次构造器必须委托给主构造器；它的函数体最后执行（⑤）
    constructor(name: String) : this(name, age = 18) {
        println("次构造器体")
    }

    // 自定义 getter：没有幕后字段，每次读都在算
    val isAdmin: Boolean
        get() = role == "admin"

    // 自定义 setter：用到了 field，所以有幕后字段
    var email: String = ""
        set(value) {
            require("@" in value)
            field = value.lowercase()   // field 只在这里可见
        }
}

// 默认 final：不加 open 就继承不了
open class Animal(val name: String) {
    open fun sound() = "..."
}
class Dog(name: String) : Animal(name) {
    override fun sound() = "汪汪"
}

// ⚠️ 基类构造期读 open 属性 —— 输出见 pitfall
open class Base {
    open val tag: String = "base"
    init { println("Base.init tag=$tag") }
}
class Sub : Base() {
    override val tag: String = "sub"
    init { println("Sub.init tag=$tag") }
}

// 抽象类：不能实例化，抽象成员隐含 open
abstract class Shape(val name: String) {
    abstract fun area(): Double          // 无实现，子类必须给
    abstract val sides: Int               // 抽象属性
    open fun describe() = "$name 面积 ${area()}"  // 有实现，允许重写
    fun id() = name.hashCode()             // 不加 open → 子类改不了
}

class Circle(val r: Double) : Shape("圆") {
    override fun area() = Math.PI * r * r
    override val sides = 0
    // 不写 override 的报错：
    //   error: 'area' hides member of supertype 'Shape' and needs an 'override' modifier.
}

// 重写后仍是 open，除非封死
open class Rect(val w: Double, val h: Double) : Shape("矩形") {
    final override fun area() = w * h    // 到此为止，孙子类不能再改
    override val sides = 4
}

// 属性重写：val 可以被 var 重写（加能力）
open class Person(open val name: String)
class Employee(override var name: String, val no: Int) : Person(name)

// 多接口默认实现冲突：必须显式选
interface A { fun hello() = "A" }
interface B { fun hello() = "B" }
class C : A, B {
    override fun hello() = super<A>.hello() + super<B>.hello()  // "AB"
    // 不重写的报错：
    //   error: class 'C' must override 'hello' because it inherits multiple interface methods for it.
}

// 多态调用：静态类型是 Shape，实际执行子类实现
val shapes: List<Shape> = listOf(Circle(1.0), Rect(2.0, 3.0))
shapes.forEach { println(it.describe()) }

data class User(val id: Int, val name: String) {
    var note: String = ""            // ⚠️ 不在主构造器里 → 不参与任何生成方法
}

val a = User(1, "Ann").apply { note = "AAA" }
val b = User(1, "Ann").apply { note = "BBB" }

println(a == b)              // true  ← note 不同，仍然相等
println(a)                   // User(id=1, name=Ann)  ← note 不出现
println(a.copy().note)       // ""    ← 被重置成默认值，不是 "AAA"

// 解构：靠生成的 componentN
val (id, name) = a

// copy 的正确用法：不可变数据的「改一个字段」
val renamed = a.copy(name = "Bob")   // User(id=1, name=Bob)

// ⚠️ copy 是浅拷贝：可变容器会被共享
data class Team(val name: String, val members: MutableList<String>)
val t1 = Team("t", mutableListOf("x"))
val t2 = t1.copy(name = "t2")
t2.members.add("y")
println(t1.members)          // [x, y]  ← t1 也变了！
println(t1.members === t2.members)   // true —— 同一个对象

// ✅ 正确做法：属性用不可变类型
data class Team2(val name: String, val members: List<String>)
val u1 = Team2("t", listOf("x"))
val u2 = u1.copy(members = u1.members + "y")   // 生成新列表，u1 不受影响

// javap -p User 生成的成员：
//   public final int component1();
//   public final java.lang.String component2();
//   public final User copy(int, java.lang.String);
//   public static User copy$default(User, int, java.lang.String, int, java.lang.Object);
//   public java.lang.String toString();
//   public int hashCode();
//   public boolean equals(java.lang.Object);
//   （note 只有 getNote/setNote，没有 component3）

// sealed interface：每种情况带自己的数据
sealed interface UiState {
    data class Success(val data: String) : UiState
    data class Error(val msg: String) : UiState
    data object Loading : UiState        // 无数据的情况用 data object
}

// 穷尽 when：不写 else，加新情况时编译器会点名所有该改的地方
fun render(s: UiState): String = when (s) {
    is UiState.Success -> s.data          // 智能转换：s 已是 Success
    is UiState.Error   -> "错误：${s.msg}"
    UiState.Loading    -> "加载中…"        // object 用 == 比较，不需要 is
}
// 漏掉 Loading 的报错：
//   error: 'when' expression must be exhaustive.
//          Add the 'Loading' branch or an 'else' branch.
// 注意：当语句用（不取返回值）也照样报这条错

// enum：每个值是单例，可以带属性和方法
enum class Color(val hex: String) {
    RED("#FF0000"),
    GREEN("#00FF00"),
    BLUE("#0000FF");

    fun isWarm() = this == RED
}

// entries vs values()（均已）
println(Color.entries)                      // [RED, GREEN, BLUE]
println(Color.entries.javaClass.name)       // kotlin.enums.EnumEntriesList
println(Color.entries[1])                   // GREEN —— 它是 List，可索引
println(Color.entries === Color.entries)   // true —— 同一个实例
println(Color.values() === Color.values())   // false —— 每次新建数组
Color.entries.filter { it.isWarm() }         // 直接用集合 API，不用先 toList()

// 什么时候 enum 不够用：需要不同数据 → 改 sealed
// ❌ enum 塞不下差异化字段
// enum class Result { SUCCESS(data?), ERROR(msg?) }   // 所有值共用同一组属性
// ✅ sealed 各带各的

// sealed 也能建模递归结构（表达式树等）
sealed interface Expr {
    data class Num(val v: Int) : Expr
    data class Add(val l: Expr, val r: Expr) : Expr
}
fun eval(e: Expr): Int = when (e) {
    is Expr.Num -> e.v
    is Expr.Add -> eval(e.l) + eval(e.r)
}

// 接口：默认实现 + 属性（无幕后字段）
interface Logger {
    val prefix: String                       // 抽象属性，实现类提供
    val banner: String get() = "[$prefix]"    // 派生属性（自定义 getter）
    // val count: Int = 0                     ❌ 接口里不能有幕后字段，报
    //   error: property initializers in interfaces are prohibited.

    fun log(msg: String)                      // 抽象
    fun warn(msg: String) = log("W: $msg")   // 默认实现
}

class Console : Logger {
    override val prefix = "con"
    override fun log(msg: String) { println("C: $msg") }
}

// 类委托：未重写的方法自动转发给 inner
class Prefixed(private val inner: Logger) : Logger by inner {
    override fun log(msg: String) { inner.log("[p] $msg") }
}

val p = Prefixed(Console())
p.log("hi")        // C: [p] hi   ← 走了重写
p.warn("careful")  // C: W: careful  ← ⚠️ 不是 "C: [p] W: careful"！见 pitfall

// 伴生对象：类的单例，不是 static
class Cfg private constructor(val id: Long) {
    companion object {                        // 可以起名字：companion object Named
        const val MAX_LEN = 50                // 唯一会变成 JVM 静态字段的形式
        fun create(id: Long) = Cfg(id)        // 能访问私有构造器 → 工厂
    }
}
val c = Cfg.create(1L)

// 伴生对象能实现接口 —— static 做不到的事
interface Factory<T> { fun of(id: Long): T }
class Item private constructor(val id: Long) {
    companion object : Factory<Item> {
        override fun of(id: Long) = Item(id)
    }
}
fun <T> build(f: Factory<T>) = f.of(1L)
build(Item)      // ✅ 直接把伴生对象当参数传

// object：单例 与 匿名对象
object Registry {                    // 单例，首次访问时初始化
    private val items = mutableListOf<String>()
    fun add(s: String) { items += s }
}
Registry.add("a")

val once = object : Logger {         // 匿名对象，一次性实现
    override val prefix = "tmp"
    override fun log(msg: String) { println(msg) }
}

import kotlin.properties.Delegates
import kotlin.properties.ReadOnlyProperty
import kotlin.reflect.KProperty

// by lazy：首次访问才算，之后缓存
class Repo {
    val db: Database by lazy {            // 默认 SYNCHRONIZED
        println("建立连接…")                  // 只在第一次用到 db 时打印
        Database.connect()
    }
    // 确定单线程访问时可省掉锁（多线程下会重复计算，慎用）
    val cache: Index by lazy(LazyThreadSafetyMode.NONE) { buildIndex() }
}

// observable：赋值之后回调（改不了结果）
class Form {
    var name: String by Delegates.observable("") { _, old, new ->
        println("name: '$old' → '$new'")
    }
}

// vetoable：赋值之前回调，返回 false 就丢弃这次赋值
class Player {
    var score: Int by Delegates.vetoable(0) { _, _, new -> new >= 0 }
}
val pl = Player()
pl.score = 10;  println(pl.score)   // 10
pl.score = -5;  println(pl.score)   // 10 —— 被否决，值没变

// notNull：lateinit 的基本类型替代品
class Conn { var port: Int by Delegates.notNull() }
// 未赋值就读，抛：
//   java.lang.IllegalStateException: Property port should be initialized before get.

// by map：属性名即键，解析配置/JSON 时省事
class Config(map: Map<String, Any?>) {
    val host: String by map
    val port: Int    by map
}
Config(mapOf("host" to "localhost", "port" to 8080)).host   // localhost
// 缺键时抛：
//   java.util.NoSuchElementException: Key port is missing in the map.

// 自定义委托 ①：约定式，实现 getValue / setValue 即可
class Trimmed {
    private var v = ""
    operator fun getValue(o: Any?, p: KProperty<*>) = v
    operator fun setValue(o: Any?, p: KProperty<*>, value: String) {
        v = value.trim()                    // 存入前自动去空白
    }
}
class Post { var title: String by Trimmed() }

// 自定义委托 ②：实现 ReadOnlyProperty 接口（SAM，可写成 lambda）
class T {
    val cfg: String by ReadOnlyProperty { _, p -> "from-${p.name}" }
}
println(T().cfg)      // from-cfg —— KProperty 带着属性名

// ① 只读接口没有 add，编译期就拦住
val ro: List<Int> = listOf(1, 2, 3)
// ro.add(4)                       // ❌ Unresolved reference 'add'

// ② 强转 listOf 的结果 —— 运行时炸
(ro as MutableList<Int>).add(4)
// java.lang.UnsupportedOperationException  （底层是 Arrays$ArrayList）

// ③ 但底层若本来就是 mutableListOf —— 强转成功，真的改掉了
val backing = mutableListOf(1, 2, 3)
val view: List<Int> = backing        // 只是换了个「只读」的声明
(view as MutableList<Int>).add(4)
println(view)                         // [1, 2, 3, 4]   ← 没有异常

// ④ 连强转都不用：别人改，你的只读引用跟着变
val b = mutableListOf("a")
val v: List<String> = b
b.add("b")
println(v)                            // [a, b]   ← 只读引用是视图，不是快照

// ⑤ toList() 才是真拷贝：源再怎么改，拷贝不动
val snapshot = b.toList()
b.add("c")
println(snapshot)                     // [a, b]
println(b)                            // [a, b, c]

// ⑥ List<out E> 协变 vs MutableList<E> 不变
val names: List<String> = listOf("a", "b")
val anys: List<Any> = names           // ✅ List 是 out E
// val m: MutableList<Any> = names   // ❌ initializer type mismatch:
//    expected 'MutableList<Any>', actual 'List<String>'.

data class Emp(val name: String, val dept: String, val salary: Int)
val es = listOf(Emp("Ann", "eng", 100), Emp("Bob", "eng", 120), Emp("Cy", "ops", 90))

// —— 变换 ——
listOf("1", "x", "3").map { it.toIntOrNull() }        // [1, null, 3]  : List<Int?>
listOf("1", "x", "3").mapNotNull { it.toIntOrNull() }  // [1, 3]        : List<Int>
listOf("ab", "cd").flatMap { it.toList() }         // [a, b, c, d]
listOf(listOf(1, 2), listOf(3)).flatten()           // [1, 2, 3]
listOf(1, 2, 3).zip(listOf("a", "b"))              // [(1, a), (2, b)] ← 按短的截断

// —— 聚合：fold 有初始值，reduce 没有 ——
listOf(1, 2, 3).fold(10) { acc, n -> acc + n }        // 16
listOf(1, 2, 3).reduce { acc, n -> acc + n }           // 6
emptyList<Int>().fold(0) { a, b -> a + b }             // 0   ← 安全
emptyList<Int>().reduce { a, b -> a + b }              // UnsupportedOperationException:
//                                       Empty collection can't be reduced.
listOf(1, 2, 3).runningFold(0) { a, b -> a + b }   // [0, 1, 3, 6] ← 要中间过程

// —— 取元素：空集合的分水岭 ——
emptyList<Int>().first()      // NoSuchElementException: List is empty.
emptyList<Int>().firstOrNull()// null
listOf(1, 2).single()         // IllegalArgumentException: List has more than one element.

// —— 分组：associateBy 会静默丢重复键 ——
es.groupBy { it.dept }
// {eng=[Emp(Ann..), Emp(Bob..)], ops=[Emp(Cy..)]}   3 条全在
es.associateBy { it.dept }
// {eng=Emp(Bob..), ops=Emp(Cy..)}                   Ann 没了！size 3 -> 2
es.groupingBy { it.dept }.eachCount()          // {eng=2, ops=1}  只要计数别 groupBy 再 size
es.associate { it.name to it.salary }          // {Ann=100, Bob=120, Cy=90}
es.partition { it.salary > 95 }                // Pair(满足的, 不满足的)

// —— 排序：多级 / null 用 sortedWith ——
es.sortedBy { it.salary }                        // 单 key
es.sortedWith(compareBy({ it.dept }, { it.name })) // 先部门后姓名
listOf("b", null, "a").sortedWith(nullsLast(naturalOrder()))  // [a, b, null]

// —— 切窗 ——
(1..7).toList().chunked(3)     // [[1,2,3], [4,5,6], [7]]  定长分块，不重叠
(1..5).toList().windowed(3)    // [[1,2,3], [2,3,4], [3,4,5]]  滑动窗口，重叠

// —— 求值顺序：横着走 vs 竖着走 ——
listOf(1, 2, 3).map { log("m${it}"); it }.filter { log("f${it}"); true }
// 顺序：m1 m2 m3 f1 f2 f3      ← map 全做完，建中间 List，filter 再扫

listOf(1, 2, 3).asSequence()
    .map { log("m${it}"); it }.filter { log("f${it}"); true }.toList()
// 顺序：m1 f1 m2 f2 m3 f3      ← 每个元素一路走到底，零中间集合

// —— 早停：map 只跑 5 次 vs 100 次 ——
(1..100).asSequence().map { it * it }.first { it > 20 }   // 25，map 调用 5 次
(1..100).map { it * it }.first { it > 20 }                // 25，map 调用 100 次

// —— 三种造法 ——
val a = listOf(1, 2, 3).asSequence()
val b = generateSequence(1) { it + 1 }          // 无限序列，靠 take/first 收口
val c = sequence { yield(1); yieldAll(listOf(2, 3)) }

// 无限 + 早停：只有惰性才写得出来
generateSequence(1) { it + 1 }.filter { it % 7 == 0 }.take(3).toList()  // [7, 14, 21]

// —— 一次性：取决于源，不是取决于 Sequence 本身 ——
val reusable = listOf(1, 2, 3).asSequence().map { it * 2 }
reusable.toList()   // [2, 4, 6]
reusable.toList()   // [2, 4, 6]   ← 再来一次，完全没问题

val src = listOf("a", "b").iterator()
val once = generateSequence { if (src.hasNext()) src.next() else null }
once.toList()       // [a, b]
once.toList()       // IllegalStateException: This sequence can be consumed only once.

// —— 逐行读文件：内存占用与文件大小无关 ——
File("big.log").useLines { lines ->          // lines: Sequence<String>
    lines.filter { it.startsWith("ERROR") }.take(10).toList()
}                                             // 块结束自动关流

// —— 拷贝 vs 视图 ——
val m = mutableListOf(1, 2, 3)
val viewR = m.asReversed()      // 视图
val copyR = m.reversed()        // 拷贝
m.add(4)
println(viewR)                 // [4, 3, 2, 1]   ← 跟着变了
println(copyR)                 // [3, 2, 1]      ← 没变

// toMutableList 是拷贝：改副本不动原件
val orig = listOf(1, 2)
val copy = orig.toMutableList()
copy.add(3)
println("${orig} / ${copy}")      // [1, 2] / [1, 2, 3]

// —— 遍历中改：单线程也会炸 ——
val xs = mutableListOf(1, 2, 3)
for (x in xs) { if (x == 2) xs.add(99) }
// java.util.ConcurrentModificationException   ← 没有第二个线程

val mp = mutableMapOf("a" to 1, "b" to 2)
for ((k, _) in mp) { mp["c"] = 3 }
// java.util.ConcurrentModificationException   ← Map 同理

// ✅ 写法一：removeIf
val a = mutableListOf(1, 2, 3, 4)
a.removeIf { it % 2 == 0 }               // [1, 3]

// ✅ 写法二：显式迭代器
val b = mutableListOf(1, 2, 3, 4)
val iter = b.iterator()
while (iter.hasNext()) { if (iter.next() % 2 == 0) iter.remove() }

// ✅ 写法三：造新集合（最 Kotlin，也最不容易错）
var c = listOf(1, 2, 3, 4)
c = c.filter { it % 2 != 0 }

// —— unmodifiableList：运行期硬拦，但仍是视图 ——
val backing = mutableListOf(1, 2)
val unmod = Collections.unmodifiableList(backing)
unmod.add(3)                    // UnsupportedOperationException
(unmod as MutableList<Int>).add(9) // 仍然 UnsupportedOperationException（强转也没用）
backing.add(3)
println(unmod)                 // [1, 2, 3]   ← 但源一改，它还是跟着变

// 只有拷贝才是真快照
val snapshot = backing.toList()

// 一屏体感：同一批数据，六族各来一句
data class Emp(val name: String, val dept: String, val salary: Int)
val es = listOf(Emp("Ann", "eng", 100), Emp("Bob", "eng", 120), Emp("Cy", "ops", 90))

es.map { it.name }                          // [Ann, Bob, Cy]
es.filter { it.salary > 95 }                // Ann, Bob
es.sumOf { it.salary }                       // 310
es.groupBy { it.dept }                       // {eng=[Ann, Bob], ops=[Cy]}
es.groupingBy { it.dept }.eachCount()        // {eng=2, ops=1}
es.sortedByDescending { it.salary }.first()  // Emp(Bob, eng, 120)
es.maxByOrNull { it.salary }                 // 同上，但不排序、也不会抛
es.joinToString("; ") { "${it.name}(${it.salary})" }
// Ann(100); Bob(120); Cy(90)

// Map 的四个高频招
val m = mapOf("a" to 1)
m["z"]                       // null
m.getOrElse("z") { -1 }      // -1
m.getValue("z")              // NoSuchElementException: Key z is missing in the map.
mutableMapOf<String, Int>().getOrPut("k") { 9 }   // 9，并写回 map

// —— 语法四级跳 ——
val a: (Int) -> Int = { n: Int -> n * 2 }   // 全写
val b: (Int) -> Int = { n -> n * 2 }        // 类型可推
val c: (Int) -> Int = { it * 2 }           // 单参数用 it
listOf(1, 2, 3).filter { it > 1 }         // 尾随 lambda，括号都省了

// —— 高阶函数：收一个函数、还一个函数 ——
fun <T> List<T>.countBy(pred: (T) -> Boolean): Int {
    var n = 0
    for (x in this) if (pred(x)) n++
    return n
}
fun multiplier(k: Int): (Int) -> Int = { it * k }   // 返回函数
multiplier(3)(5)                                     // 15

// —— 函数引用 ——
val len: (String) -> Int = String::length
listOf("a", "bb").map(String::length)                // [1, 2]
listOf(1, 2).forEach(::println)

// —— 带接收者的函数类型：lambda 里 this 就是接收者 ——
fun tag(name: String, body: StringBuilder.() -> Unit): String =
    StringBuilder().apply { append("<$name>"); body(); append("</$name>") }.toString()
tag("p") { append("hello") }        // <p>hello</p>   append 前不用写 this.

// —— SAM：Java 接口直接传 lambda ——
val r: Runnable = Runnable { println("run") }     // ✅ Java SAM

fun interface Transformer { fun apply(s: String): String }
fun useSam(t: Transformer) = t.apply("kotlin")
useSam { it.uppercase() }                          // KOTLIN  （靠 fun interface）

// —— 闭包能捕获并修改 var（Java 不行）——
fun makeCounter(): () -> Int {
    var count = 0              // 被 lambda 捕获且修改
    return { ++count }
}
val next = makeCounter()
println("${next()} ${next()} ${next()}")         // 1 2 3

var total = 0
listOf(1, 2, 3).forEach { total += it }          // total == 6
// javap: total 被装进 kotlin.jvm.internal.Ref$IntRef（堆上的可变盒子）

// 同样的 Java 代码编译不过：
//   int count = 0;
//   Supplier<Integer> s = () -> ++count;
//   error: local variables referenced from a lambda expression
//          must be final or effectively final

// —— 五个函数的返回值，—
val sb = StringBuilder()
sb.apply { append("x"); 999 }   // → sb 本身；999 被丢弃（warning: expression is unused.）
sb.run   { append("y"); 999 }   // → 999
sb.let   { it.append("z"); 111 } // → 111
sb.also  { it.append("w"); 222 } // → sb 本身；222 被丢弃
with(sb) { length }              // → 长度（Int）

// —— let：可空处理的主力 ——
val name: String? = readLine()
val upper = name?.let { it.trim().uppercase() }   // name 为 null 时整个是 null

// —— apply：新建 + 配置，返回对象本身 ——
val conf = Properties().apply {
    setProperty("host", "localhost")     // this 隐式，不用写 conf.
    setProperty("port", "8080")
}

// —— also：链中间插一脚，不改变链上流动的值 ——
val ids = loadUsers()
    .also { log("loaded ${it.size}") }      // 路过看一眼
    .filter { it.active }
    .also { log("active ${it.size}") }
    .map { it.id }

// —— run：配置 + 算一个结果 ——
val ok = conf.run {
    setProperty("retry", "3")
    getProperty("host") != null          // 最后一句就是返回值
}

// —— with：针对某对象做一串事 ——
val desc = with(StringBuilder()) {
    append("a"); append("b")
    toString()
}

// ❌ 坑一：apply 里想返回结果 —— 白写
// val n = sb.apply { length }      // n 是 sb，不是长度！只有 warning
val n = sb.run { length }        // ✅ 要结果用 run

// ❌ 坑二：嵌套 let，里层 it 遮蔽外层，无警告
// a.let { b.let { it /* 这是 b，a 够不着了 */ } }
a.let { outer -> b.let { inner -> "$outer / $inner" } }   // ✅ 显式命名

// —— 基本形态 ——
fun String.removeSpaces(): String = this.replace(" ", "")
"hello world".removeSpaces()          // "helloworld"

// 可空接收者：对 null 也能调（this 就是 null）
fun String?.orDefault(d: String = "N/A") = this ?: d
val s: String? = null
s.orDefault()                          // "N/A"   ← 注意没有 ?.

// 扩展属性：必须是计算属性
val String.firstChar: Char get() = this[0]
// val String.cached: Int = this.length   // ❌ extension property cannot be
//                                        //    initialized because it has no backing field.

// 伴生对象扩展：写出来像静态工厂
fun Int.Companion.randomUpTo(n: Int) = (0..n).random()
Int.randomUpTo(10)

// —— 静态分派：同一个对象，两种结果 ——
open class Animal
class Dog : Animal()
fun Animal.speak() = "Animal.speak"
fun Dog.speak()    = "Dog.speak"

val d: Dog    = Dog()
val a: Animal = d                       // 同一个对象，换个声明类型
println(d.speak())                      // Dog.speak
println(a.speak())                      // Animal.speak   ← 按声明类型选！

// javap -p FpxKt 揭示真相：它俩就是两个静态方法重载
//   public static final java.lang.String speak(Animal);
//   public static final java.lang.String speak(Dog);
//   public static final char getFirstChar(java.lang.String);

// —— 成员永远赢 ——
class Box { fun show() = "MEMBER" }
fun Box.show() = "EXTENSION"
// warning: this extension is shadowed by a member:
//          'fun show(): String' defined in 'Box'.
Box().show()                           // MEMBER

// —— 访问不了 private ——
class D { private val hidden = 1 }
// fun D.peek() = hidden
// error: cannot access 'val hidden: Int': it is private in 'D'.

// —— 「不可变」只是只读视图：+ 是整份拷贝 ——
val a = listOf(1, 2, 3)
val b = a + 4              // 新建一个完整的 List，不是结构共享
// 循环里这么写就是 O(n²)：
// var acc = emptyList<Int>(); repeat(n) { acc = acc + it }   ← 别
val acc = buildList { repeat(1000) { add(it) } }   // ✅ 可变累积，只读交付

// —— 没有 HKT：这行写不出来 ——
// interface Functor<F<_>> { fun <A, B> F<A>.map(f: (A) -> B): F<B> }
// Kotlin 的泛型参数只能是具体类型，不能是「一个类型构造器」

// —— 没有 monad，但有够用的组合子 ——
val n: Int? = readLine()?.trim()?.toIntOrNull()      // ?. 链 ≈ Maybe
val r: Result<Int> = runCatching { "12".toInt() }
    .map { it * 2 }
    .recover { 0 }                                // ≈ Either 的两条腿
val sum = listOf(1, 2, 3).fold(0) { s, x -> s + x }  // 折叠就是折叠，不谈 monoid

// —— tailrec：编译成循环 ——
tailrec fun sumTail(n: Int, acc: Long = 0): Long =
    if (n == 0) acc else sumTail(n - 1, acc + n)      // 递归调用是最后一步 ✅

fun sumPlain(n: Int): Long =
    if (n == 0) 0 else n + sumPlain(n - 1)          // 调用后还要做加法 ❌ 不是尾调用

sumTail(1_000_000)     // 正常返回结果
sumPlain(1_000_000)    // java.lang.StackOverflowError

// javap -c 里的差别：
//   sumTail :  23: goto 0                        ← 循环，无自我调用
//   sumPlain:  13: invokestatic sumPlain:(I)J    ← 真递归

// 标错了只有警告，不是错误 —— 照常编译，照常炸栈
// warning: a function is marked as tail-recursive but no tail calls are found.
// warning: recursive call is not a tail call.

// —— val 不等于不可变 ——
val box = mutableListOf(1)
box.add(2)                // ✅ 合法：val 冻住的是引用，不是对象
// box = mutableListOf()  // ❌ 这才是 val 拦得住的

// —— 基本形态 ——
fun <T> firstOf(xs: List<T>): T = xs[0]
class Box<T>(val v: T)

// 上界：不写默认是 Any?（可空）
fun <T : Comparable<T>> biggest(a: T, b: T): T = if (a > b) a else b
fun <T : Any> notNull(v: T): T = v          // 显式禁止 null

// 多个上界必须用 where
fun <T> describe(v: T): Int where T : CharSequence, T : Comparable<T> = v.length

// —— 擦除：运行时它们是同一个类 ——
println(listOf("a").javaClass == listOf(1).javaClass)   // true

// javap -s 看真正的描述符：两个方法一模一样
//   int takeStrings(java.util.List<java.lang.String>);
//     descriptor: (Ljava/util/List;)I
//   int takeInts(java.util.List<java.lang.Integer>);
//     descriptor: (Ljava/util/List;)I      ← 尖括号只是元数据

// —— 不能拿 T 当类型来用 ——
fun <T> noReified(): String = T::class.java.name
// error: cannot use 'T' as reified type parameter. Use a class instead.

inline fun <reified T> nameOf() = T::class.java.name   // ✅ 加 inline + reified
nameOf<List<String>>()      // "java.util.List"   ← 注意：内层 String 依旧被擦掉了

// —— 非受检转型：爆炸被推迟到读取时 ——
val any: Any = listOf("a", "b")
val asInts = any as List<Int>      // ⚠️ 只是 unchecked cast 警告，这一步不抛
println(asInts.size)               // 2   ← 还是没事
val n: Int = asInts[0]            // 💥 这里才炸
// java.lang.ClassCastException: class java.lang.String cannot be cast
//   to class java.lang.Number

// —— 泛型数组是擦除最疼的地方 ——
val arr = arrayOfNulls<Any>(2) as Array<String>
// java.lang.ClassCastException: class [Ljava.lang.Object;
//   cannot be cast to class [Ljava.lang.String;
// 数组把元素类型带到了运行时（见下一卡），所以这一步就地爆炸

// ========== 问题：Java 数组协变的运行时陷阱==========
// Java:
//   String[] strs = new String[2];
//   Object[] objs = strs;                  // ✅ 编译通过：Java 数组是协变的
//   objs[0] = Integer.valueOf(42);         // 💥 运行时
//   java.lang.ArrayStoreException: java.lang.Integer

// Kotlin：Array<T> 不变，同样的代码编译期就拦下
val strs: Array<String> = arrayOf("a", "b")
// val objs: Array<Any> = strs
// error: initializer type mismatch: expected 'Array<Any>', actual 'Array<String>'.

// ========== out：只生产，可以协变 ==========
interface Source<out T> {
    fun next(): T          // ✅ 输出位置
    // fun put(t: T)        // ❌ error: type parameter 'T' is declared as 'out'
    //                      //    but occurs in 'in' position in type 'T (of ...)'.
}
val s: Source<String> = ListSource(listOf("hi"))
val o: Source<Any> = s        // ✅ 协变：拿 String 当 Any 用，安全
println(o.next())             // hi

// ========== in：只消费，可以逆变 ==========
interface Sink<in T> {
    fun put(t: T)          // ✅ 输入位置
    // fun get(): T         // ❌ ... declared as 'in' but occurs in 'out' position
}
val anySink: Sink<Any> = PrintSink()
val strSink: Sink<String> = anySink   // ✅ 逆变：能吞 Any 的当然能吞 String
strSink.put("hello")

// ========== 不变：MutableList ==========
val names: List<String> = listOf("a")
val anys: List<Any> = names           // ✅ List 声明为 List<out E>
// val m: MutableList<Any> = names    // ❌ initializer type mismatch:
//                                    //    expected 'MutableList<Any>', actual 'List<String>'
// 幸好拦住了：否则 m.add(42) 就能往一堆 String 里塞 Int

// ========== 使用处型变（投影）：这一处只读 ==========
fun copyAll(from: Array<out Any>, to: Array<Any>) {   // from 只读 → out 投影
    for (i in from.indices) to[i] = from[i]
}
copyAll(arrayOf("a", "b"), arrayOfNulls<Any>(2) as Array<Any>)
// 对应 Java 的 void copyAll(Object[] from, ...) 里的 <? extends Object>

// ========== 星投影：不关心类型实参 ==========
fun describe(c: Collection<*>) = "size=${c.size}, empty=${c.isEmpty()}"
describe(listOf(1, 2, 3))       // size=3, empty=false
describe(setOf("a"))            // size=1, empty=false

// 星投影禁止写入
fun bad(xs: MutableList<*>) { xs.add("nope") }
// error: receiver type 'MutableList<*>' contains star projection
//        which prohibits the use of 'fun add(element: E): Boolean'.