// 一段代码能同时用到本页大半章节
import kotlinx.coroutines.*

sealed interface Result<out T> {                       // 06 章 sealed + 09 章型变
    data class Ok<T>(val data: T) : Result<T>
    data class Err(val code: Int)   : Result<Nothing>
}

suspend fun load(ids: List<Int>): List<Repo> = coroutineScope {   // 10 章结构化并发
    ids.map { async { api.fetch(it) } }               // 并发发起
       .awaitAll()                                     // 一起等
       .filterIsInstance<Result.Ok<Repo>>()               // 07 章集合操作
       .map { it.data }
       .sortedByDescending { it.stars }
}

fun describe(r: Result<*>): String = when (r) {         // 03 章 when 是表达式
    is Result.Ok  -> "拿到 ${r.data}"                     // 02 章字符串模板
    is Result.Err -> "失败 ${r.code}"
}                                                     // sealed：不用写 else

// 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

// build.gradle.kts —— 决定语言版本的就是 plugins 那一行
plugins {
    kotlin("jvm") version "2.4.10"        // ← 语言特性由它决定
    application
}

kotlin {
    jvmToolchain(21)                      // JVM 目标，和 Kotlin 版本是两回事
}

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")  // 独立版本号
    testImplementation(kotlin("test"))
}

// 2.x 落地的两个写法，2.4 上直接可用
sealed interface Route {
    data object Home : Route          // 1.9：toString 打印 Home 而不是 Route$Home@1b6d
    data class User(val id: Long) : Route
}

fun classify(x: Any): String = when (x) {
    is String if x.isEmpty() -> "空串"      // 2.x：guard condition
    is String                -> "串:${x.length}"
    is Int if x > 0        -> "正数"
    else                     -> "其他"
}

# 从零到跑通：四条命令
$ mkdir demo && cd demo
$ gradle init --type kotlin-application --dsl kotlin
$ ./gradlew run                       # 编译 + 运行
$ ./gradlew test                      # 跑测试

// src/main/kotlin/Main.kt —— 最小但完整的程序
import kotlin.system.exitProcess

fun main(args: Array<String>) {
    val name = args.firstOrNull() ?: run {      // 05 章：?: 兜底
        System.err.println("用法: demo <名字>")
        exitProcess(2)                            // 返回类型是 Nothing，能当值用
    }
    println("你好 $name，参数共 ${args.size} 个")   // 02 章：字符串模板
}

// build.gradle.kts —— 一个能跑的最小配置
plugins {
    kotlin("jvm") version "2.4.10"
    application
}
repositories { mavenCentral() }
dependencies { testImplementation(kotlin("test")) }
kotlin { jvmToolchain(21) }
application { mainClass.set("MainKt") }     // Main.kt 的顶层函数 → MainKt

// ① 最常见的三条编译错误与它们的正解
var name: String? = load()

// println(name.length)          → Only safe (?.) or non-null asserted calls…
println(name?.length ?: 0)          // 安全调用 + 兜底

if (name != null) {
    // println(name.length)      → Smart cast impossible：name 是 var 属性
}
val n = name                       // ← 先固定成局部 val
if (n != null) println(n.length)   // 智能转换这才生效

// ② when 用作表达式时必须穷尽
sealed interface S { data object A : S; data object B : S }
fun f(s: S) = when (s) {           // sealed：编译器知道只有两种
    S.A -> "a"
    S.B -> "b"
}                                   // 不写 else；将来加一种会在这里报错（这正是目的）

// ③ 一条典型的 Gradle 报错：真正的原因在上面
e: file:///…/Main.kt:12:15 Unresolved reference: launch   // ← 看这一行
> Task :compileKotlin FAILED                              //   不是这一行
// 修：import kotlinx.coroutines.launch（或依赖没加）

// 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 了。

// ① val 管的是「指向谁」，不是「内容能不能改」
val list = mutableListOf(1, 2)
list.add(3)              // 合法：改的是内容
// list = mutableListOf()  // 不合法：改的是指向

// ② 没有隐式加宽，这是从 Java 过来最容易撞的一条
val i = 1
// val l: Long = i       → Type mismatch
val l: Long = i.toLong()    // 显式转换

// ③ 解析输入：一律 OrNull 版本
val n = readlnOrNull()?.trim()?.toIntOrNull() ?: 0

// ④ 原始字符串 + trimIndent：正则和 JSON 直接粘
val re = Regex("""\d{4}-\d{2}-\d{2}""")      // 不用写 \\d
val json = """
    { "name": "张三", "path": "C:\temp" }
""".trimIndent()

// ⑤ 模板：单变量不用大括号，表达式要
val name = "世界"
println("你好 $name，长度 ${name.length}")      // 你好 世界，长度 2

// ⑥ == 是值相等，=== 才是引用相等（和 Java 相反）
val a = "ab"; val b = StringBuilder("ab").toString()
println(a == b)    // true
println(a === b)   // false

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

// ① when 作表达式：一次搞定判断 + 取值 + 类型转换
fun describe(x: Any?): String = when (x) {
    null            -> "空"
    is String if x.isEmpty() -> "空串"          // 2.x guard
    is String       -> "字符串，长 ${x.length}"       // 这里 x 已是 String
    in 1..9         -> "个位数"
    is List<*>       -> "列表，${x.size} 项"
    else            -> "其他"
}

// ② 不带参数的 when：取代一长串 else-if
val level = when {
    score >= 90 -> "优"
    score >= 60 -> "及格"
    else        -> "不及格"
}

// ③ 范围与遍历：没有 C 风格 for
for (i in 0..<list.size) { }              // 不含 size
for ((i, x) in list.withIndex()) { }        // 带下标
for (i in 10 downTo 1 step 2) { }          // 10 8 6 4 2
repeat(3) { println(it) }                    // 0 1 2

// ④ lambda 里的 return：裸 return 会返回外层函数
fun find(xs: List<Int>) {
    xs.forEach {
        if (it < 0) return@forEach            // 跳过这一项（相当于 continue）
        if (it == 99) return                   // 直接结束整个 find
    }
}

// ⑤ 大文件按行处理：useLines 流式，不把整个文件读进内存
val count = File("big.log").useLines { lines ->
    lines.filter { "ERROR" in it }.count()
}

// —— 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 connect(
    host: String,
    port: Int = 443,
    useTls: Boolean = true,
    timeoutMs: Int = 5_000,
) { }

connect("api.example.com")                          // 全用默认
connect("api.example.com", timeoutMs = 30_000)       // 只改一个
// connect("h", 443, true, 30000)   ← 三个月后没人知道 true 是什么

// ② vararg：传数组要展开
fun log(tag: String, vararg parts: String) = println("[$tag] ${parts.joinToString(" ")}")
val arr = arrayOf("a", "b")
log("net", *arr)                                 // ← 星号展开

// ③ 局部函数：只在这里用的逻辑不必暴露出去
fun process(items: List<Item>): Report {
    fun score(i: Item) = i.weight * factor      // 能用外层的 factor
    return Report(items.sumOf(::score))
}

// ④ 函数引用：能写方法名就别写 lambda
val nums = listOf("1", "2").map(String::toInt)      // 比 { it.toInt() } 更直接
val users = rows.map(::User)                     // 构造器引用

// ⑤ 给 Java 调用方留门
@JvmOverloads
fun retry(times: Int = 3, delayMs: Long = 100) { }  // Java 侧才有 retry()/retry(n)

// —— 块体：必须写返回类型 ——
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 关键字不能省

// ① 四种处理可空的姿势，按推荐度排
val name: String? = load()

val a = name ?: "匿名"                  // 给兜底
val b = name ?: return                    // 提前退出（之后 name 已收窄）
name?.let { println(it.length) }          // 非空才做
// val c = name!!.length                 // 最后手段：错了就是 NPE

// ② 「Smart cast is impossible」的标准解法
class Box(var value: String?) {
    fun show() {
        // if (value != null) println(value.length)   → 编译错：value 是 var 属性
        val v = value ?: return            // ← 固定成局部 val
        println(v.length)
    }
}

// ③ 平台类型：Java 来的值要在边界上表态
val raw = javaConfig.getName()            // 推断成 String!（可空性未知）
val safe: String? = javaConfig.getName()  // ← 显式标成可空，后面就有保护
println(safe?.uppercase() ?: "(无)")

// ④ try 是表达式；runCatching 更紧凑
val n = try { s.toInt() } catch (e: NumberFormatException) { 0 }
val m = s.toIntOrNull() ?: 0            // 这个场景其实不该用异常

// ⑤ 集合里的 null：一次过滤干净
val names: List<String?> = listOf("a", null, "b")
val clean: List<String> = names.filterNotNull()

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))

// ① 数据用 data class：一行换来五样东西
data class User(val id: Long, val name: String, val vip: Boolean = false)

val u  = User(1, "张三")
val u2 = u.copy(vip = true)                  // 复制并改一个字段
val (id, name) = u                            // 解构
println(u == User(1, "张三"))                  // true（比内容）
println(u)                                    // User(id=1, name=张三, vip=false)

// ② 「有限几种情况」用 sealed：when 不用写 else
sealed interface UiState {
    data object Loading : UiState
    data class  Ok(val items: List<User>) : UiState
    data class  Err(val msg: String)      : UiState
}

fun render(s: UiState) = when (s) {
    UiState.Loading -> "加载中"
    is UiState.Ok  -> "共 ${s.items.size} 条"
    is UiState.Err -> "出错：${s.msg}"
}   // 将来加一种 Empty，这里会立刻编译报错 —— 这正是目的

// ③ 属性：自定义访问器与 field
class Rect(val w: Int, val h: Int) {
    val area get() = w * h                   // 每次访问都算，不占存储
    var label: String = ""
        set(v) { field = v.trim() }          // field = 幕后字段
}

// ④ 接口委托：只改要改的那一个方法
interface Repo { fun find(id: Long): User?; fun all(): List<User> }

class CachingRepo(private val inner: Repo) : Repo by inner {   // all() 自动转发
    private val cache = mutableMapOf<Long, User>()
    override fun find(id: Long) = cache.getOrPut(id) { inner.find(id) ?: return null }
}

// ⑤ 属性委托：贵的初始化推迟到第一次用
val config: Config by lazy { parse(File("app.yaml").readText()) }

// 主构造器写在类头，参数前加 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 带着属性名