泛型进阶

// 基础泛型类声明 - 单个类型参数
class Box<T>(private val item: T) {  // T 是类型参数，在整个类内部可用
    
    // 返回存储的元素，返回类型是 T
    fun get(): T {
        return item  // item 的类型是 T
    }
    
    // 判断是否为空 - 演示类型参数的使用
    fun isEmpty(): Boolean {
        return item == null  // 可以对 T 类型进行 null 检查
    }
    
    // 打印元素信息
    fun printInfo() {
        println("Box contains: $item")  // T 类型可以进行字符串插值
    }
}
 
// 使用泛型类 - 类型实参 (Type Argument)
fun main() {
    // 创建存储 String 的 Box，T 被具体化为 String
    val stringBox = Box<String>("Hello Kotlin")  
    val content: String = stringBox.get()  // 编译器知道返回类型是 String
    println(content)  // 输出: Hello Kotlin
    
    // 创建存储 Int 的 Box，T 被具体化为 Int
    val intBox = Box<Int>(42)  
    val number: Int = intBox.get()  // 返回类型是 Int，无需类型转换
    println(number)  // 输出: 42
    
    // 类型推断 - 编译器自动推断 T 为 Double
    val doubleBox = Box(3.14)  // 等价于 Box<Double>(3.14)
    println(doubleBox.get())  // 输出: 3.14
}

// 演示类型参数在类内部的全方位使用
class Container<T>(initialValue: T) {  // 构造函数参数类型为 T
    
    private var value: T = initialValue  // 属性类型为 T
    
    // 函数参数类型为 T
    fun set(newValue: T) {
        value = newValue  // 赋值操作，类型安全
    }
    
    // 返回类型为 T
    fun get(): T {
        return value
    }
    
    // 函数内部局部变量也可以使用 T
    fun transform(mapper: (T) -> T): T {  // 高阶函数，参数和返回值都是 T
        val oldValue: T = value  // 局部变量类型为 T
        val newValue: T = mapper(oldValue)  // 通过函数转换得到新值
        value = newValue
        return newValue
    }
    
    // 类型参数用于集合
    fun toList(): List<T> {  // 返回 List<T> 类型
        return listOf(value)
    }
}
 
fun main() {
    val container = Container(10)  // 推断为 Container<Int>
    
    container.set(20)  // 参数必须是 Int
    // container.set("error")  // 编译错误！类型不匹配
    
    val doubled = container.transform { it * 2 }  // lambda 参数和返回值都是 Int
    println(doubled)  // 输出: 40
    
    val list: List<Int> = container.toList()  // 返回 List<Int>
    println(list)  // 输出: [40]
}

// 双类型参数 - 键值对容器
class Pair<K, V>(  // K 代表 Key 类型，V 代表 Value 类型
    val key: K,     // 第一个类型参数用于键
    val value: V    // 第二个类型参数用于值
) {
    // 返回键，类型是 K
    fun getKey(): K = key
    
    // 返回值，类型是 V
    fun getValue(): V = value
    
    // 创建反转的键值对 - 展示类型参数的灵活组合
    fun swap(): Pair<V, K> {  // 返回类型将 K 和 V 互换
        return Pair(value, key)  // 原来的 value 作为新的 key
    }
    
    // 重写 toString 用于调试
    override fun toString(): String {
        return "Pair(key=$key, value=$value)"
    }
}
 
fun main() {
    // K 是 String，V 是 Int
    val pair1 = Pair<String, Int>("age", 25)
    println(pair1)  // 输出: Pair(key=age, value=25)
    
    // 类型推断 - K 是 Int，V 是 String
    val pair2 = Pair(404, "Not Found")  
    println(pair2)  // 输出: Pair(key=404, value=Not Found)
    
    // 交换键值对 - 返回 Pair<String, Int>
    val swapped: Pair<String, Int> = pair2.swap()  
    println(swapped)  // 输出: Pair(key=Not Found, value=404)
    
    // 多层嵌套泛型
    val nested = Pair<String, Pair<Int, Boolean>>(
        "status", 
        Pair(200, true)
    )
    println(nested.value.key)  // 输出: 200
}

// 三类型参数 - 高级缓存类
class Cache<K, V, M>(  
    // K: 键类型
    // V: 值类型
    // M: 元数据类型 (Metadata)，例如缓存时间、访问次数等
    private val maxSize: Int = 100
) {
    // 内部存储结构 - Map 的键是 K，值是包含 V 和 M 的 Entry
    private val storage = mutableMapOf<K, Entry<V, M>>()
    
    // 内部类也可以使用外部类的类型参数
    data class Entry<V, M>(
        val value: V,       // 实际缓存的值
        val metadata: M     // 关联的元数据
    )
    
    // 存入缓存 - 三个类型参数都得到使用
    fun put(key: K, value: V, metadata: M) {
        if (storage.size >= maxSize) {
            // 移除最早的条目 (简化示例)
            storage.remove(storage.keys.first())
        }
        storage[key] = Entry(value, metadata)  // 创建 Entry<V, M>
    }
    
    // 获取值 - 返回 V? 类型
    fun get(key: K): V? {
        return storage[key]?.value  // 从 Entry 中提取 value
    }
    
    // 获取元数据 - 返回 M? 类型
    fun getMetadata(key: K): M? {
        return storage[key]?.metadata  // 从 Entry 中提取 metadata
    }
    
    // 获取完整条目 - 返回 Entry<V, M>? 类型
    fun getEntry(key: K): Entry<V, M>? {
        return storage[key]
    }
    
    // 条件过滤 - 高阶函数结合泛型
    fun filterByMetadata(predicate: (M) -> Boolean): List<Pair<K, V>> {
        // predicate 函数接受 M 类型参数
        return storage
            .filter { (_, entry) -> predicate(entry.metadata) }  // 过滤元数据
            .map { (key, entry) -> Pair(key, entry.value) }      // 映射为键值对
    }
}
 
// 定义元数据类型
data class CacheMetadata(
    val timestamp: Long,      // 缓存时间戳
    val accessCount: Int = 0  // 访问次数
)
 
fun main() {
    // 创建缓存: 键是 String，值是 User 对象，元数据是 CacheMetadata
    val cache = Cache<String, User, CacheMetadata>()
    
    // 存入数据
    cache.put(
        key = "user:1001",
        value = User("Alice", 28),
        metadata = CacheMetadata(System.currentTimeMillis(), 0)
    )
    
    cache.put(
        key = "user:1002",
        value = User("Bob", 35),
        metadata = CacheMetadata(System.currentTimeMillis() - 1000, 5)
    )
    
    // 获取值
    val user: User? = cache.get("user:1001")
    println(user)  // 输出: User(name=Alice, age=28)
    
    // 获取元数据
    val meta: CacheMetadata? = cache.getMetadata("user:1002")
    println("Access count: ${meta?.accessCount}")  // 输出: Access count: 5
    
    // 过滤高访问量的条目
    val hotData = cache.filterByMetadata { it.accessCount > 3 }
    println("Hot data: $hotData")  // 输出被频繁访问的用户
}
 
data class User(val name: String, val age: Int)

class Repository<T>(
    private val dataSource: DataSource<T>  // 类型参数用于依赖注入
) {
    // 缓存属性 - 使用可空的 T
    private var cachedData: T? = null  
    
    // 集合属性 - 嵌套泛型
    private val history: MutableList<T> = mutableListOf()  
    
    // 延迟属性 - 与泛型结合
    private val defaultValue: T by lazy {  
        dataSource.getDefault()  // 返回类型必须是 T
    }
    
    fun fetch(): T {
        // 先检查缓存
        cachedData?.let { return it }  // 智能转换为非空 T
        
        // 从数据源获取
        val data: T = dataSource.load()  // 明确类型为 T
        
        // 更新缓存和历史
        cachedData = data
        history.add(data)  // MutableList<T>.add(T)
        
        return data
    }
    
    fun getHistory(): List<T> {  // 返回不可变列表
        return history.toList()  // List<T>
    }
}
 
// 数据源接口 - 也是泛型
interface DataSource<T> {
    fun load(): T
    fun getDefault(): T
}
 
// 具体实现
class StringDataSource : DataSource<String> {
    override fun load(): String = "Loaded data"
    override fun getDefault(): String = "Default value"
}
 
fun main() {
    val repo = Repository(StringDataSource())  // 推断为 Repository<String>
    
    val data: String = repo.fetch()  // 类型安全，无需转换
    println(data)
        
    val history: List<String> = repo.getHistory()
    println(history)
}

class Tree<T>(val value: T) {  // 外部类的类型参数 T
    
    // 嵌套类 - 不能直接访问外部类的 T
    class StaticNode<U>(val data: U) {  // 独立的类型参数 U
        fun process(): U = data
    }
    
    // 内部类 - 可以访问外部类的 T
    inner class Node(val nodeValue: T) {  // 使用外部类的 T
        
        // 内部类也可以有自己的类型参数
        fun <R> transform(converter: (T) -> R): R {  
            // 函数级别的类型参数 R
            return converter(nodeValue)  // T 转换为 R
        }
        
        // 访问外部类的属性
        fun isRoot(): Boolean {
            return nodeValue == this@Tree.value  // 比较与外部 T 值
        }
    }
    
    // 使用内部类创建节点
    private val children = mutableListOf<Node>()
    
    fun addChild(childValue: T): Node {  // 参数类型是 T
        val node = Node(childValue)  // 创建内部类实例
        children.add(node)
        return node
    }
    
    // 遍历所有子节点
    fun getAllChildren(): List<T> {  // 返回 List<T>
        return children.map { it.nodeValue }  // 提取所有 T 类型的值
    }
}
 
fun main() {
    val tree = Tree<Int>(1)  // 根节点值为 1
    
    // 添加子节点
    val child1 = tree.addChild(2)
    val child2 = tree.addChild(3)
    
    // 内部类的方法
    println(child1.isRoot())  // 输出: false
    
    // 泛型函数调用
    val stringValue: String = child1.transform { "Number: $it" }
    println(stringValue)  // 输出: Number: 2
    
    // 获取所有子节点值
    val values: List<Int> = tree.getAllChildren()
    println(values)  // 输出: [2, 3]
    
    // 静态嵌套类 - 独立的类型参数
    val staticNode = Tree.StaticNode<String>("Independent")
    println(staticNode.process())  // 输出: Independent
}

class Stack<E> {  // 栈结构，E 代表 Element
    private val elements = mutableListOf<E>()  // 内部使用 List<E> 存储
    
    fun push(element: E) {  // 压栈
        elements.add(element)
    }
    
    fun pop(): E? {  // 出栈
        return if (elements.isEmpty()) null else elements.removeAt(elements.lastIndex)
    }
    
    fun peek(): E? {  // 查看栈顶
        return elements.lastOrNull()
    }
    
    fun size(): Int = elements.size
}
 
// 扩展函数 - 使用类的类型参数 E
fun <E> Stack<E>.pushAll(items: Collection<E>) {  
    // 需要重新声明类型参数 E
    items.forEach { push(it) }  // 每个 item 的类型是 E
}
 
// 扩展函数 - 带约束的类型参数
fun <E : Comparable<E>> Stack<E>.max(): E? {  
    // E 必须实现 Comparable 接口
    var maxElement: E? = null
    while (size() > 0) {
        val current = pop()!!  // 非空断言，因为 size > 0
        if (maxElement == null || current > maxElement) {
            maxElement = current
        }
    }
    return maxElement
}
 
fun main() {
    val stack = Stack<Int>()  // Int 栈
    stack.push(5)
    stack.push(3)
    
    // 使用扩展函数批量压栈
    stack.pushAll(listOf(8, 1, 9))  // Collection<Int>
    
    println("Stack size: ${stack.size()}")  // 输出: Stack size: 5
    
    // 查找最大值 - Int 实现了 Comparable
    val maxValue = stack.max()  
    println("Max value: $maxValue")  // 输出: Max value: 9
    
    // 注意：max() 会清空栈（因为实现中使用了 pop）
    println("After max, size: ${stack.size()}")  // 输出: After max, size: 0
}

class Processor<T> {
    private var current: T? = null  // 可空的 T
    
    fun process(input: T): T {  // 输入和输出都是 T
        current = input  // 类型匹配，允许赋值
        
        // val wrong: String = input  // 编译错误！T 可能不是 String
        
        // 类型安全的操作
        val result: T = performOperation(input)  // 函数返回 T
        return result
    }
    
    private fun performOperation(data: T): T {
        // 这里只能执行对所有类型通用的操作
        println("Processing: $data")  // toString() 对所有类型可用
        return data  // 返回相同的值
    }
    
    // 类型参数用于泛型约束
    fun <R> convert(converter: (T?) -> R): R {  
        // 将 T? 转换为任意类型 R
        return converter(current)
    }
}
 
fun main() {
    val processor = Processor<Double>()  // T 是 Double
    
    val result: Double = processor.process(3.14)  // 输入输出都是 Double
    println(result)
    
    // processor.process("text")  // 编译错误！String 不是 Double
    
    // 类型转换
    val intValue: Int = processor.convert { it?.toInt() ?: 0 }
    println(intValue)  // 输出: 3
}

// 最基础的泛型函数：交换两个变量的值
fun <T> swap(a: T, b: T): Pair<T, T> {
    // 返回一个 Pair，第一个元素是 b，第二个元素是 a
    return Pair(b, a)
}
 
// 使用示例
fun main() {
    val result1 = swap(10, 20)           // T 推断为 Int
    println(result1)                      // 输出: (20, 10)
    
    val result2 = swap("hello", "world") // T 推断为 String
    println(result2)                      // 输出: (world, hello)
    
    // 显式指定类型参数（通常不需要，编译器会自动推断）
    val result3 = swap<Double>(3.14, 2.71)
    println(result3)                      // 输出: (2.71, 3.14)
}

// 定义一个将两个不同类型的值转换为 Pair 的函数
fun <A, B> makePair(first: A, second: B): Pair<A, B> {
    // 创建并返回一个包含两个不同类型元素的 Pair
    return Pair(first, second)
}
 
// 定义一个类型转换函数，将 A 类型转换为 B 类型
fun <A, B> convert(value: A, transformer: (A) -> B): B {
    // 调用传入的转换函数 transformer，将 A 类型的值转换为 B 类型
    return transformer(value)
}
 
// 使用示例
fun main() {
    // A=Int, B=String
    val pair = makePair(42, "answer")
    println(pair)  // 输出: (42, answer)
    
    // A=String, B=Int，将字符串长度作为转换结果
    val length = convert("Hello") { it.length }
    println(length)  // 输出: 5
    
    // A=Int, B=Double，将整数转换为浮点数
    val doubled = convert(10) { it.toDouble() * 2 }
    println(doubled)  // 输出: 20.0
}

// 泛型列表过滤函数
fun <T> filter(list: List<T>, predicate: (T) -> Boolean): List<T> {
    val result = mutableListOf<T>()  // 根据 T 创建可变列表
    for (element in list) {          // 遍历输入列表
        if (predicate(element)) {     // 如果元素满足谓词条件
            result.add(element)       // 添加到结果列表
        }
    }
    return result                     // 返回过滤后的列表
}
 
fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    // 编译器从 numbers 的类型 List<Int> 推断出 T = Int
    // 无需写成 filter<Int>(numbers) { ... }
    val evenNumbers = filter(numbers) { it % 2 == 0 }
    println(evenNumbers)  // 输出: [2, 4, 6, 8, 10]
    
    val strings = listOf("apple", "banana", "cherry", "date")
    // 编译器从 strings 的类型 List<String> 推断出 T = String
    val longWords = filter(strings) { it.length > 5 }
    println(longWords)  // 输出: [banana, cherry]
}

// 创建一个包含单个元素的列表
fun <T> singletonList(element: T): List<T> {
    // 使用 listOf 创建只包含一个元素的不可变列表
    return listOf(element)
}
 
fun main() {
    // 从返回值的期望类型推断 T = String
    val names: List<String> = singletonList("Alice")
    
    // 也可以从传入参数推断
    val numbers = singletonList(42)  // T 推断为 Int
    
    // 如果推断不明确，可以显式指定
    val mixed = singletonList<Any>("text")  // 明确指定 T = Any
}

fun <T> identity(value: T): T = value
 
fun main() {
    // 这种情况推断明确
    val str = identity("hello")  // T = String
    
    // 当传入 null 字面量时，编译器无法推断具体类型
    // val x = identity(null)  // ❌ 编译错误：类型推断失败
    
    // 需要显式指定类型参数
    val x = identity<String?>(null)  // ✅ T = String?
    
    // 或者通过上下文提供类型信息
    val y: Int? = identity(null)  // ✅ 从变量类型推断 T = Int?
}

// 约束 T 必须是 Comparable<T> 的子类型
// 这样我们就能在函数内部使用 compareTo 方法
fun <T : Comparable<T>> max(a: T, b: T): T {
    // 因为 T 必须实现 Comparable<T>，所以可以调用 compareTo
    return if (a.compareTo(b) > 0) a else b
}
 
fun main() {
    println(max(10, 20))           // 输出: 20 (Int 实现了 Comparable<Int>)
    println(max("apple", "banana")) // 输出: banana (String 实现了 Comparable<String>)
    println(max(3.14, 2.71))       // 输出: 3.14 (Double 实现了 Comparable<Double>)
    
    // ❌ 以下代码无法编译，因为自定义类没有实现 Comparable
    // data class Person(val name: String)
    // println(max(Person("Alice"), Person("Bob")))
}

// 约束 T 必须是 Number 的子类，这样可以安全地进行数值操作
fun <T : Number> sum(numbers: List<T>): Double {
    var total = 0.0  // 累加器，使用 Double 避免精度损失
    for (number in numbers) {
        // Number 类提供了 toDouble() 方法，将任意数值类型转换为 Double
        total += number.toDouble()
    }
    return total
}
 
fun main() {
    val integers = listOf(1, 2, 3, 4, 5)
    println(sum(integers))  // 输出: 15.0
    
    val doubles = listOf(1.5, 2.5, 3.5)
    println(sum(doubles))  // 输出: 7.5
    
    val mixed: List<Number> = listOf(1, 2.5, 3L, 4.5f)
    println(sum(mixed))  // 输出: 11.0
}

// T 默认上界是 Any?，可以接受可空类型
fun <T> printHashCode(value: T) {
    // value 可能为 null，需要使用安全调用
    println(value?.hashCode())
}
 
// 显式约束 T 必须是非空类型
fun <T : Any> printHashCodeNonNull(value: T) {
    // value 保证不为 null，可以直接调用方法
    println(value.hashCode())
}
 
fun main() {
    printHashCode(null)           // 输出: null
    printHashCode("hello")        // 输出: 99162322
    
    // printHashCodeNonNull(null) // ❌ 编译错误：类型不匹配
    printHashCodeNonNull("hello") // 输出: 99162322
}

// 上界约束示例：T 必须是 CharSequence 的子类型
fun <T : CharSequence> printLength(text: T) {
    // 因为 T 继承自 CharSequence，所以可以安全访问 length 属性
    println("Length: ${text.length}")
    
    // CharSequence 的所有成员都可以使用
    println("First char: ${text.firstOrNull()}")
    println("Substring: ${text.subSequence(0, minOf(3, text.length))}")
}
 
fun main() {
    printLength("Hello")              // String 实现了 CharSequence
    printLength(StringBuilder("Hi"))  // StringBuilder 实现了 CharSequence
    
    // ❌ 以下代码无法编译
    // printLength(123)  // Int 不是 CharSequence 的子类型
}

// 定义一个图形接口
interface Shape {
    fun area(): Double  // 计算面积
}
 
// 圆形实现
class Circle(val radius: Double) : Shape {
    override fun area() = Math.PI * radius * radius
}
 
// 矩形实现
class Rectangle(val width: Double, val height: Double) : Shape {
    override fun area() = width * height
}
 
// 泛型函数：计算形状列表的总面积
// T 必须是 Shape 的子类型，这样才能调用 area() 方法
fun <T : Shape> totalArea(shapes: List<T>): Double {
    var sum = 0.0                    // 初始化累加器
    for (shape in shapes) {          // 遍历所有图形
        sum += shape.area()          // 调用 area() 方法（多态调用）
    }
    return sum
}
 
fun main() {
    val circles = listOf(
        Circle(5.0),
        Circle(3.0)
    )
    println("Total area of circles: ${totalArea(circles)}")
    // 输出: Total area of circles: 100.53096491487338
    
    val rectangles = listOf(
        Rectangle(4.0, 5.0),
        Rectangle(3.0, 6.0)
    )
    println("Total area of rectangles: ${totalArea(rectangles)}")
    // 输出: Total area of rectangles: 38.0
    
    // 混合类型列表（使用 Shape 作为公共父类型）
    val mixedShapes: List<Shape> = listOf(
        Circle(2.0),
        Rectangle(3.0, 4.0)
    )
    println("Total area of mixed shapes: ${totalArea(mixedShapes)}")
    // 输出: Total area of mixed shapes: 24.566370614359172
}

// 递归类型约束：T 必须是 Comparable<T>
// 这保证了 T 类型的对象可以与同类型的其他对象进行比较
fun <T : Comparable<T>> findMin(values: List<T>): T? {
    if (values.isEmpty()) return null  // 空列表返回 null
    
    var min = values[0]               // 假设第一个元素是最小值
    for (i in 1 until values.size) {  // 从第二个元素开始遍历
        if (values[i] < min) {        // 使用 compareTo 进行比较（操作符重载）
            min = values[i]            // 更新最小值
        }
    }
    return min
}
 
fun main() {
    println(findMin(listOf(5, 2, 8, 1, 9)))  // 输出: 1
    println(findMin(listOf("zebra", "apple", "mango")))  // 输出: apple
    
    // 自定义类型，只要实现了 Comparable 就可以使用
    data class Person(val name: String, val age: Int) : Comparable<Person> {
        override fun compareTo(other: Person): Int = age.compareTo(other.age)
    }
    
    val people = listOf(
        Person("Alice", 30),
        Person("Bob", 25),
        Person("Charlie", 35)
    )
    println(findMin(people))  // 输出: Person(name=Bob, age=25)
}

// 要求 T 同时实现 CharSequence 和 Comparable<T>
fun <T> processText(text: T)
    where T : CharSequence,
          T : Comparable<T> {
    
    // 可以使用 CharSequence 的成员
    println("Length: ${text.length}")
    println("First 3 chars: ${text.take(3)}")
    
    // 可以使用 Comparable 的成员
    val comparison = text.compareTo(text)
    println("Compare with itself: $comparison")
}
 
fun main() {
    // String 同时实现了 CharSequence 和 Comparable<String>
    processText("Hello Kotlin")
    
    // ❌ StringBuilder 实现了 CharSequence 但没有实现 Comparable
    // processText(StringBuilder("Hi"))  // 编译错误
}

import java.io.Serializable
 
// 泛型函数：存储并排序数据
// T 必须同时满足：可序列化 + 可比较
fun <T> storeAndSort(items: List<T>): List<T>
    where T : Serializable,
          T : Comparable<T> {
    
    // 因为 T 是 Serializable，理论上可以持久化（这里简化处理）
    println("Storing ${items.size} items...")
    
    // 因为 T 是 Comparable，可以进行排序
    return items.sorted()  // sorted() 要求元素实现 Comparable
}
 
fun main() {
    // String 实现了 Serializable 和 Comparable<String>
    val words = listOf("zebra", "apple", "mango", "banana")
    val sorted = storeAndSort(words)
    println(sorted)  // 输出: [apple, banana, mango, zebra]
    
    // Int 也同时实现了这两个接口
    val numbers = listOf(5, 2, 8, 1, 9)
    val sortedNumbers = storeAndSort(numbers)
    println(sortedNumbers)  // 输出: [1, 2, 5, 8, 9]
}

// 定义基础接口
interface Drawable {
    fun draw()
}
 
interface Clickable {
    fun onClick(handler: () -> Unit)
}
 
// 自定义类型必须同时实现 Drawable 和 Clickable
class Button : Drawable, Clickable {
    private var clickHandler: (() -> Unit)? = null
    
    override fun draw() {
        println("Drawing a button")
    }
    
    override fun onClick(handler: () -> Unit) {
        clickHandler = handler
    }
    
    fun performClick() {
        println("Button clicked!")
        clickHandler?.invoke()
    }
}
 
// 泛型函数：配置可绘制且可点击的组件
fun <T> setupComponent(component: T, config: T.() -> Unit): T
    where T : Drawable,
          T : Clickable {
    
    component.draw()        // 调用 Drawable 接口的方法
    component.config()      // 执行配置代码块
    return component
}
 
fun main() {
    val button = setupComponent(Button()) {
        // 在配置块中，this 是 Button 实例
        // 可以调用 Drawable 和 Clickable 的所有方法
        onClick {
            println("Button action executed!")
        }
    }
    
    button.performClick()
    // 输出:
    // Drawing a button
    // Button clicked!
    // Button action executed!
}

// K 和 V 都有各自的约束
fun <K, V> processMap(map: Map<K, V>)
    where K : Comparable<K>,
          V : Number {
    
    // 可以对 Key 进行排序（因为 K 实现了 Comparable）
    val sortedKeys = map.keys.sorted()
    println("Sorted keys: $sortedKeys")
    
    // 可以对 Value 进行数值计算（因为 V 是 Number 的子类型）
    val sum = map.values.sumOf { it.toDouble() }
    println("Sum of values: $sum")
}
 
fun main() {
    val scoreMap = mapOf(
        "Alice" to 95,
        "Bob" to 87,
        "Charlie" to 92
    )
    
    processMap(scoreMap)
    // 输出:
    // Sorted keys: [Alice, Bob, Charlie]
    // Sum of values: 274.0
}

// 协变类型参数 out T，同时有上界约束
interface Producer<out T : Number> {
    fun produce(): T  // 只能生产 T，不能消费
}
 
// 具体实现
class IntProducer(private val value: Int) : Producer<Int> {
    override fun produce(): Int = value
}
 
class DoubleProducer(private val value: Double) : Producer<Double> {
    override fun produce(): Double = value
}
 
// 泛型函数：处理任意 Number 子类型的生产者
fun processProducer(producer: Producer<Number>) {
    val value = producer.produce()
    println("Produced value: $value (${value::class.simpleName})")
}
 
fun main() {
    // 由于 Producer 是协变的（out T），可以将 Producer<Int> 赋值给 Producer<Number>
    processProducer(IntProducer(42))       // 输出: Produced value: 42 (Int)
    processProducer(DoubleProducer(3.14))  // 输出: Produced value: 3.14 (Double)
}

fun <T : Comparable<T>> sortAndFilter(items: List<T>, threshold: T): List<T> {
    return items.filter { it > threshold }.sorted()
}
 
fun main() {
    val numbers = listOf(1, 5, 3, 8, 2, 9, 4)
    println(sortAndFilter(numbers, 5))
}

// 定义一个不变的泛型类
class Box<T>(var item: T) {  // T 没有任何型变修饰符，默认是不变的
    fun get(): T = item       // 可以读取
    fun set(value: T) {       // 也可以写入
        item = value
    }
}
 
// 类型层次
open class Animal(val name: String)
class Cat(name: String) : Animal(name)
class Dog(name: String) : Animal(name)
 
fun demonstrateInvariance() {
    val catBox: Box<Cat> = Box(Cat("Kitty"))
    val animalBox: Box<Animal> = Box(Animal("Generic"))
    
    // ❌ 编译错误！即使 Cat 是 Animal 的子类型
    // Box<Cat> 和 Box<Animal> 之间没有继承关系
    // val boxRef: Box<Animal> = catBox  // Type mismatch
    
    // 为什么不允许？假设允许的话：
    // boxRef.set(Dog("Buddy"))  // 尝试放入 Dog
    // val cat: Cat = catBox.get()  // 实际取出的是 Dog，类型不安全！
}

// 协变的生产者接口（只输出，不输入）
interface Producer<out T> {  // out 关键字声明 T 是协变的
    fun produce(): T         // ✅ T 在输出位置（返回值）
    // fun consume(item: T)  // ❌ 编译错误！T 不能在输入位置（参数）
}
 
// 具体实现
class AnimalProducer : Producer<Animal> {
    override fun produce(): Animal = Animal("Generic Animal")
}
 
class CatProducer : Producer<Cat> {
    override fun produce(): Cat = Cat("Meow")
}
 
fun demonstrateCovariance() {
    val catProducer: Producer<Cat> = CatProducer()
    
    // ✅ 协变允许：Producer<Cat> 可以赋值给 Producer<Animal>
    // 因为只要能生产 Cat，就一定能生产 Animal（Cat 是 Animal 的子类）
    val animalProducer: Producer<Animal> = catProducer
    
    val animal: Animal = animalProducer.produce()  // 安全：返回的一定是 Animal（实际是 Cat）
    
    // 为什么安全？因为不能写入：
    // animalProducer.consume(Dog("Buddy"))  // 这个方法根本不存在！
}

fun covariantListExample() {
    val cats: List<Cat> = listOf(Cat("Whiskers"), Cat("Shadow"))
    
    // ✅ List 是协变的，List<Cat> 是 List<Animal> 的子类型
    val animals: List<Animal> = cats
    
    // 安全读取：取出的元素一定是 Animal（实际是 Cat）
    val firstAnimal: Animal = animals[0]
    
    // 为什么安全？List 是只读的，不能修改：
    // animals.add(Dog("Rex"))  // ❌ List 没有 add 方法
}

// 逆变的消费者接口（只输入，不输出）
interface Consumer<in T> {   // in 关键字声明 T 是逆变的
    fun consume(item: T)      // ✅ T 在输入位置（参数）
    // fun produce(): T       // ❌ 编译错误！T 不能在输出位置（返回值）
}
 
// 具体实现
class AnimalConsumer : Consumer<Animal> {
    override fun consume(item: Animal) {
        println("消费动物: ${item.name}")
    }
}
 
class CatConsumer : Consumer<Cat> {
    override fun consume(item: Cat) {
        println("消费猫咪: ${item.name}")
    }
}
 
fun demonstrateContravariance() {
    val animalConsumer: Consumer<Animal> = AnimalConsumer()
    
    // ✅ 逆变允许：Consumer<Animal> 可以赋值给 Consumer<Cat>
    // 因为能消费 Animal 的，一定能消费 Cat（Cat 是 Animal）
    val catConsumer: Consumer<Cat> = animalConsumer
    
    // 安全写入：传入 Cat，AnimalConsumer 能处理任何 Animal
    catConsumer.consume(Cat("Fluffy"))
    
    // 为什么安全？不能读取：
    // val cat: Cat = catConsumer.produce()  // 这个方法根本不存在！
}

fun contravariantComparatorExample() {
    // 一个通用的 Animal 比较器（按名字比较）
    val animalComparator = Comparator<Animal> { a1, a2 -> 
        a1.name.compareTo(a2.name)
    }
    
    val cats = listOf(Cat("Zara"), Cat("Alice"), Cat("Bob"))
    
    // ✅ Comparator<Animal> 可以用于排序 List<Cat>
    // 因为能比较 Animal 的，一定能比较 Cat
    val sortedCats = cats.sortedWith(animalComparator)
    
    sortedCats.forEach { println(it.name) }  // 输出: Alice, Bob, Zara
}

// 对比三种型变
fun varianceComparison() {
    // 1. 不变 (Invariant)：既能读又能写
    val invariantBox: Box<Cat> = Box(Cat("Kitty"))
    invariantBox.set(Cat("New Cat"))  // ✅ 可写
    val cat1: Cat = invariantBox.get()  // ✅ 可读
    // val animalBox: Box<Animal> = invariantBox  // ❌ 无继承关系
    
    // 2. 协变 (Covariant)：只能读
    val covariantProducer: Producer<Cat> = CatProducer()
    val animal: Animal = covariantProducer.produce()  // ✅ 可读
    // covariantProducer.consume(Cat("New"))  // ❌ 不存在写入方法
    val animalProducer: Producer<Animal> = covariantProducer  // ✅ 有继承关系（正向）
    
    // 3. 逆变 (Contravariant)：只能写
    val contravariantConsumer: Consumer<Animal> = AnimalConsumer()
    contravariantConsumer.consume(Cat("Fluffy"))  // ✅ 可写
    // val result = contravariantConsumer.produce()  // ❌ 不存在读取方法
    val catConsumer: Consumer<Cat> = contravariantConsumer  // ✅ 有继承关系（反向）
}

// 声明处协变：在类定义时就指定 T 是协变的
interface Source<out T> {  // out 关键字使 T 协变
    fun nextItem(): T      // ✅ T 在输出位置（返回值）
    
    // fun addItem(item: T)  // ❌ 编译错误！
    // Error: Type parameter T is declared as 'out' but occurs in 'in' position
}
 
// 实现协变接口
class StringSource : Source<String> {
    private var count = 0
    
    override fun nextItem(): String {
        return "Item ${++count}"
    }
}
 
class NumberSource : Source<Number> {
    private var value = 0.0
    
    override fun nextItem(): Number {
        return value++
    }
}
 
fun useCovariantSource() {
    val stringSource: Source<String> = StringSource()
    
    // ✅ 协变允许向上转型
    val anySource: Source<Any> = stringSource
    
    val item: Any = anySource.nextItem()  // 安全：返回的是 String，属于 Any
    println(item)
}

// Kotlin 标准库中的 List 接口（简化版）
public interface List<out E> : Collection<E> {
    override val size: Int
    override fun isEmpty(): Boolean
    override fun contains(element: @UnsafeVariance E): Boolean  // 特殊处理
    override fun iterator(): Iterator<E>
    
    public operator fun get(index: Int): E  // ✅ E 在输出位置
    public fun indexOf(element: @UnsafeVariance E): Int  // 特殊处理
    
    // 注意：没有 add(element: E) 方法
    // 因为 E 是协变的，不能在输入位置
}
 
fun covariantListUsage() {
    // 创建一个 String 列表
    val strings: List<String> = listOf("Kotlin", "Java", "Scala")
    
    // ✅ List<String> 是 List<Any> 的子类型
    val objects: List<Any> = strings
    
    // 安全读取
    val firstObject: Any = objects[0]  // 返回 "Kotlin"
    
    // 无法修改（List 是只读的）
    // objects.add("Python")  // ❌ Unresolved reference: add
}

// 声明处逆变：在类定义时就指定 T 是逆变的
interface Sink<in T> {     // in 关键字使 T 逆变
    fun addItem(item: T)   // ✅ T 在输入位置（参数）
    
    // fun getItem(): T    // ❌ 编译错误！
    // Error: Type parameter T is declared as 'in' but occurs in 'out' position
}
 
// 实现逆变接口
class AnySink : Sink<Any> {
    private val items = mutableListOf<Any>()
    
    override fun addItem(item: Any) {
        items.add(item)
        println("Added: $item")
    }
}
 
fun useContravariantSink() {
    val anySink: Sink<Any> = AnySink()
    
    // ✅ 逆变允许向下转型（反向）
    val stringSink: Sink<String> = anySink
    
    // 安全写入：传入 String，AnySink 能处理任何 Any
    stringSink.addItem("Hello")
    stringSink.addItem("World")
    
    // 无法读取
    // val item: String = stringSink.getItem()  // ❌ 方法不存在
}

// Kotlin 标准库中的 Comparator（简化版）
public fun interface Comparator<in T> {  // T 是逆变的
    public fun compare(a: T, b: T): Int  // ✅ T 在输入位置
}
 
fun contravariantComparator() {
    // 为所有 Number 定义比较器
    val numberComparator = Comparator<Number> { a, b ->
        a.toDouble().compareTo(b.toDouble())
    }
    
    val integers = listOf(5, 2, 8, 1, 9)
    
    // ✅ Comparator<Number> 可以用于 List<Int>
    // 因为 Int 是 Number，能比较 Number 就能比较 Int
    val sorted = integers.sortedWith(numberComparator)
    
    println(sorted)  // [1, 2, 5, 8, 9]
}

// PECS 原则示例
class DataProcessor {
    
    // 生产者：从 source 中读取数据
    // source 只生产元素，不消费 → 使用 out（协变）
    fun <T> copyFrom(source: Source<out T>): List<T> {
        val result = mutableListOf<T>()
        repeat(3) {
            result.add(source.nextItem())  // 只读取，不写入
        }
        return result
    }
    
    // 消费者：向 sink 中写入数据
    // sink 只消费元素，不生产 → 使用 in（逆变）
    fun <T> copyTo(items: List<T>, sink: Sink<in T>) {
        items.forEach { item ->
            sink.addItem(item)  // 只写入，不读取
        }
    }
    
    // 完整的复制操作
    fun <T> copy(source: Source<out T>, sink: Sink<in T>) {
        repeat(3) {
            val item = source.nextItem()  // 从 source 读取
            sink.addItem(item)            // 向 sink 写入
        }
    }
}
 
fun pecsExample() {
    val processor = DataProcessor()
    
    // 生产者示例：String 生产者可以赋值给 Any 生产者
    val stringSource: Source<String> = StringSource()
    val anySource: Source<Any> = stringSource  // ✅ 协变
    
    val items: List<Any> = processor.copyFrom(anySource)
    
    // 消费者示例：Any 消费者可以赋值给 String 消费者
    val anySink: Sink<Any> = AnySink()
    val stringSink: Sink<String> = anySink  // ✅ 逆变
    
    processor.copyTo(listOf("A", "B", "C"), stringSink)
    
    // 组合使用
    processor.copy(stringSource, anySink)
}

// Java 风格（使用处型变）
// List<? extends Animal> animals = catList;  // 每次使用都要声明
// void processList(List<? extends Animal> list) { }  // 每个方法都要写通配符
 
// Kotlin 风格（声明处型变）
interface ReadOnlyList<out E> {  // 一次声明，处处受益
    fun get(index: Int): E
    val size: Int
}
 
// 使用时无需再声明型变
fun processList(list: ReadOnlyList<Animal>) {  // 简洁明了
    // 可以传入 ReadOnlyList<Cat>
}
 
fun advantagesOfDeclarationSiteVariance() {
    val cats: ReadOnlyList<Cat> = object : ReadOnlyList<Cat> {
        override fun get(index: Int) = Cat("Cat $index")
        override val size = 10
    }
    
    // ✅ 直接传递，无需额外声明
    processList(cats)
    
    // Kotlin 的型变声明在类型定义处，使用处自动享受好处
    // Java 需要在每个使用点都写 ? extends Animal，容易遗漏且繁琐
}

// MutableList 声明为不变类型
// class MutableList<T> { ... }
 
// 使用处协变投影 - 只能读取，不能写入
fun printAnimals(animals: MutableList<out Animal>) {
    // ✅ 允许：读取操作，返回 Animal 类型
    for (animal in animals) {
        println(animal.name)
    }
    
    // ❌ 禁止：写入操作会导致编译错误
    // animals.add(Dog("Buddy")) // Error: Out-projected type prohibits the use of 'add'
}
 
// 现在可以传入子类型的 MutableList
val cats: MutableList<Cat> = mutableListOf(Cat("Whiskers"))
printAnimals(cats) // ✅ 类型安全

// 使用处逆变投影 - 只能写入，不能读取
fun addCats(destination: MutableList<in Cat>) {
    // ✅ 允许：写入 Cat 或其子类
    destination.add(Cat("Mittens"))
    destination.add(PersianCat("Fluffy")) // PersianCat extends Cat
    
    // ❌ 禁止：读取操作返回类型不确定
    // val cat: Cat = destination[0] // Error: Type mismatch
    // 只能读取为 Any?
    val item: Any? = destination[0] // ✅ 但实际用处不大
}
 
// 可以传入父类型的 MutableList
val animals: MutableList<Animal> = mutableListOf()
addCats(animals) // ✅ 安全：Cat 是 Animal 的子类

// 声明处型变 vs 使用处型变
 
// 1️⃣ 声明处协变（类定义时决定）
class Producer<out T>(private val value: T) {
    fun get(): T = value
    // fun set(value: T) {} // ❌ 编译错误：out 位置不允许
}
 
// 使用时无需额外标注
val producer: Producer<Cat> = Producer(Cat("Tom"))
val animalProducer: Producer<Animal> = producer // ✅ 自动协变
 
// 2️⃣ 使用处协变（使用时决定）
class Box<T>(private var value: T) {  // 不变类型
    fun get(): T = value
    fun set(value: T) { this.value = value }
}
 
// 使用时通过投影限制操作
fun processBox(box: Box<out Animal>) {
    val animal = box.get() // ✅ 可以读取
    // box.set(Dog("Max")) // ❌ 不能写入
}
 
val catBox: Box<Cat> = Box(Cat("Luna"))
processBox(catBox) // ✅ 使用处协变投影使其成为可能

// 从任意 Animal 子类的列表复制到目标列表
fun <T : Animal> copyAnimals(
    from: List<out T>,        // 源：只读，接受子类型
    to: MutableList<in T>     // 目标：只写，接受父类型
) {
    // from 只能读取，保证不会修改源
    for (item in from) {
        to.add(item)  // to 只能写入 T 或其子类
    }
}
 
// 实际使用
val cats: List<Cat> = listOf(Cat("A"), Cat("B"))
val animals: MutableList<Animal> = mutableListOf()
 
copyAnimals(cats, animals) // ✅ 完美匹配
// cats 作为 List<out Cat> -> 可以读取
// animals 作为 MutableList<in Cat> -> 可以写入 Cat

// Comparator 的定义（简化版）
interface Comparator<in T> {
    fun compare(a: T, b: T): Int
}
 
// Animal 的比较器
val animalComparator = Comparator<Animal> { a, b ->
    a.name.compareTo(b.name)
}
 
// ✅ 可以用来比较 Cat（因为 Comparator<in T> 是逆变的）
val cats = listOf(Cat("Zoe"), Cat("Alex"))
val sortedCats = cats.sortedWith(animalComparator)
 
// 这是合理的：如果能比较所有 Animal，当然也能比较 Cat

// 1️⃣ 双重投影的限制
fun problematic(
    list: MutableList<out Animal> // 协变投影
) {
    // 想要再次投影为逆变？这是不允许的
    // val contravariantList: MutableList<in Cat> = list // ❌ 编译错误
    // 类型投影是单向的，不能重复改变方向
}
 
// 2️⃣ 空投影（什么都不能做）
fun useless(list: MutableList<*>) { // 星号投影，后续章节详解
    // 不能读取有意义的类型（只能读到 Any?）
    val item: Any? = list[0]
    
    // 也不能写入任何类型（除了 null）
    // list.add("anything") // ❌ 编译错误
    list.add(null) // ✅ 但几乎没用
}
 
// 3️⃣ 嵌套泛型的投影
fun nested(
    map: Map<String, out List<Animal>> // 外层不变，内层协变
) {
    val animals: List<Animal>? = map["pets"]
    // 可以读取 List<Animal> 或其子类型如 List<Cat>
}

// 实践建议：
 
// ✅ 优先使用声明处型变（如果你控制类型定义）
interface Source<out T> {  // 明确这是生产者
    fun produce(): T
}
 
// ✅ 使用处型变作为补充（处理外部不变类型）
fun processArray(array: Array<out Animal>) {
    // Array 本身是不变的，但我们只需要读取
}
 
// ❌ 避免混用导致混淆
class Confusing<out T> {  // 已经声明为协变
    // 使用处再投影没有意义
    fun bad(param: Confusing<out T>) { } // 冗余且令人困惑
}

// Kotlin 标准库中的 List 定义（简化版）
public interface List<out E> : Collection<E> {
    // ✅ 所有方法都是只读的，E 只出现在 out 位置
    override val size: Int
    override fun isEmpty(): Boolean
    override fun contains(element: @UnsafeVariance E): Boolean
    override fun iterator(): Iterator<E>
    
    // 索引访问也是只读的
    public operator fun get(index: Int): E
    public fun indexOf(element: @UnsafeVariance E): Int
}
 
// 得益于协变设计，我们可以自然地进行子类型转换
val cats: List<Cat> = listOf(
    Cat("Whiskers"),
    Cat("Mittens")
)
 
// ✅ 子类型列表可以赋值给父类型列表引用
val animals: List<Animal> = cats
 
// ✅ 可以安全地读取，类型为 Animal
for (animal in animals) {
    println(animal.makeSound())
}
 
// ✅ 传递给接受 List<Animal> 的函数
fun feedAnimals(animals: List<Animal>) {
    animals.forEach { it.eat() }
}
 
feedAnimals(cats) // 完全类型安全

// MutableList 的定义（简化版）
public interface MutableList<E> : List<E>, MutableCollection<E> {
    // ❌ E 出现在 in 位置（函数参数），无法协变
    override fun add(element: E): Boolean
    override fun remove(element: E): Boolean
    
    // ❌ E 同时出现在 in 和 out 位置，无法协变也无法逆变
    public operator fun set(index: Int, element: E): E
    
    // ⚠️ 如果 MutableList 协变会发生什么？
}
 
// 假设 MutableList 是协变的（实际不是）
// 这将导致类型安全问题：
 
fun hypotheticalProblem() {
    val cats: MutableList<Cat> = mutableListOf(Cat("Tom"))
    
    // 假设可以协变赋值
    // val animals: MutableList<Animal> = cats // ❌ 实际编译错误
    
    // 如果上面成立，就能做这种事：
    // animals.add(Dog("Max"))  // 💥 把 Dog 加到 Cat 列表里！
    
    // 然后从原始引用读取：
    // val cat: Cat = cats[1]  // 💥 运行时崩溃：Dog cannot be cast to Cat
}
 
// 正确的做法：MutableList 保持不变
val cats: MutableList<Cat> = mutableListOf(Cat("Tom"))
// val animals: MutableList<Animal> = cats // ❌ 编译错误，类型不匹配
 
// 如果需要协变行为，显式转换为只读 List
val animals: List<Animal> = cats // ✅ 安全，因为 List 是协变的

// 实践中的正确用法
 
// 1️⃣ 当只需要读取时，使用 List
fun printAllAnimals(animals: List<Animal>) {  // 接受任何 Animal 子类的列表
    animals.forEach { println(it.name) }
}
 
val cats: List<Cat> = listOf(Cat("A"), Cat("B"))
printAllAnimals(cats) // ✅ 协变使得这成为可能
 
// 2️⃣ 当需要修改时，使用精确类型或泛型
fun addCat(cats: MutableList<Cat>) {  // 必须精确匹配 Cat
    cats.add(Cat("New"))
}
 
// 或使用泛型函数提供灵活性
fun <T : Animal> addAnimal(animals: MutableList<T>, animal: T) {
    animals.add(animal)  // 类型安全：只能添加 T 类型
}
 
val dogList = mutableListOf<Dog>()
addAnimal(dogList, Dog("Buddy")) // ✅ T 推断为 Dog
// addAnimal(dogList, Cat("Whiskers")) // ❌ 编译错误

// Kotlin 函数类型的定义（概念展示）
// interface Function1<in P, out R> {
//     operator fun invoke(p: P): R
// }
 
// 示例：理解函数类型的型变
typealias AnimalProcessor = (Animal) -> Animal
 
// 1️⃣ 返回值协变：返回更具体的类型是安全的
val catProducer: (Animal) -> Cat = { Cat("Generated") }
val processor: AnimalProcessor = catProducer
// ✅ 安全：期待 Animal，得到 Cat（Cat 是 Animal 的子类）
 
val result: Animal = processor(Dog("Input"))
// result 实际是 Cat，但声明为 Animal，完全安全
 
// 2️⃣ 参数逆变：接受更宽泛的类型是安全的
val anyConsumer: (Any) -> Animal = { 
    Animal("Default", if (it is String) it else "Unknown")
}
val animalConsumer: (Animal) -> Animal = anyConsumer
// ✅ 安全：传入 Animal，函数接受 Any（Any 是 Animal 的父类）
 
val cat = Cat("Test")
animalConsumer(cat) // 函数实际接受 Any，接受 Cat 绝对没问题

open class Animal(val name: String) {
    open fun makeSound() = "Some sound"
}
 
class Cat(name: String) : Animal(name) {
    override fun makeSound() = "Meow"
}
 
class Dog(name: String) : Animal(name) {
    override fun makeSound() = "Woof"
}
 
// 基准函数类型
typealias AnimalTransformer = (Animal) -> Animal
 
// ✅ 允许的替换 1：参数更宽泛（Any），返回更具体（Cat）
val superAcceptor: (Any) -> Cat = { obj ->
    when (obj) {
        is Animal -> Cat("Transformed-${obj.name}")
        else -> Cat("Default")
    }
}
val transformer1: AnimalTransformer = superAcceptor
// 原因：传入 Animal 时，函数接受 Any（更宽），没问题
//       期待返回 Animal，函数返回 Cat（更具体），也没问题
 
// ✅ 允许的替换 2：只改变返回类型为子类
val catReturner: (Animal) -> Cat = { Cat("Result-${it.name}") }
val transformer2: AnimalTransformer = catReturner
 
// ✅ 允许的替换 3：只改变参数类型为父类
val anyAcceptor: (Any) -> Animal = { 
    if (it is Animal) it else Animal("Unknown", "Unknown")
}
val transformer3: AnimalTransformer = anyAcceptor
 
// ❌ 禁止的替换 1：参数更具体（违反逆变）
val catOnly: (Cat) -> Animal = { it }
// val transformer4: AnimalTransformer = catOnly // 编译错误！
// 原因：可能传入 Dog，但函数只接受 Cat
 
// ❌ 禁止的替换 2：返回类型更宽泛（违反协变）
val anyReturner: (Animal) -> Any = { it }
// val transformer5: AnimalTransformer = anyReturner // 编译错误！
// 原因：期待 Animal，但可能返回 String 等非 Animal 类型

// 实际案例：map 函数的签名
// public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>
 
val cats: List<Cat> = listOf(Cat("A"), Cat("B"))
 
// 1️⃣ 利用协变：cats 是 List<Cat>，也是 List<Animal>
val animalList: List<Animal> = cats
 
// 2️⃣ 函数参数的型变
val names: List<String> = cats.map { animal: Animal ->  // 参数类型可以是父类
    animal.name  // 但实际接收的是 Cat
}
 
// 3️⃣ 组合使用：filter 和 map
fun processPets(animals: List<Animal>): List<String> {
    return animals
        .filter { it is Cat }  // 返回 List<Animal>（协变）
        .map { it.name }       // Animal 有 name 属性，安全
}
 
val mixedPets: List<Animal> = listOf(Cat("Tom"), Dog("Max"), Cat("Luna"))
val catNames = processPets(mixedPets) // ["Tom", "Luna"]