Kotlin：如何使用类型令牌安全处理星投影泛型？

我们有一个通过类型令牌实现具体化的Kotlin泛型类：

class Gen<X : Any>(val token: KClass<X>) {
    fun doSomething(x: X) {
        // ...
    }
}

当以星投影Gen<*>的方式异构使用该类时，尝试通过类型令牌匹配值来调用doSomething方法会直接编译失败。如果引入unchecked强制类型转换，虽然能编译，但存在安全隐患——可能传入错误类型的参数导致ClassCastException：

fun m(g: Gen<*>, x: Any) {
    if (g.token == x::class) {
        g as Gen<Any>
        g.doSomething(x)
        g.doSomething(8) // 这里会潜在触发ClassCastException
    }
}

这是不是唯一的处理方式？有没有更类型安全的方案？

优化尝试 #

引入动态类型T后，安全性有所提升：

fun <T : Any> m(g: Gen<*>, x: T) {
    if (g.token == x::class) {
        g as Gen<T>

        g.doSomething(x) // 编译正常，类型安全
        g.doSomething(8) // 编译失败，因为类型不匹配
    }
}

这里的if条件和类型转换结合，实现了类型令牌的校验作用，后续代码处于安全状态。但我们希望把检查/转换逻辑和业务逻辑解耦并封装起来，不过尝试的封装方案仍存在安全问题：

fun <T : Any> Gen<*>.ifMatches(x: T, code: (Gen<T>) -> Unit) {
    if (token == x::class) {
        code(this as Gen<T>)
    }
}

fun main() {
    val g: Gen<*> = Gen(String::class)
    val x: Any = "hello"
    g.ifMatches(x) { it.doSomething(8) } // 潜在ClassCastException风险
}  

如何实现安全的逻辑封装，或者有没有其他更安全的处理方式？

之前的封装问题在于：当调用者传入的x是Any类型时，类型参数T会被推导为Any，导致类型转换this as Gen<T>实际变成Gen<Any>，完全失去了类型约束。我们可以通过**具体化类型参数（reified）**结合运行时类型校验来实现安全封装：

方案1：绑定具体类型的封装 #

inline fun <reified T : Any> Gen<*>.ifMatches(code: (Gen<T>) -> Unit) {
    if (token == T::class) {
        code(this as Gen<T>)
    }
}

// 带值校验的版本
inline fun <reified T : Any> Gen<*>.ifMatches(x: T, code: (Gen<T>, T) -> Unit) {
    if (token == T::class) {
        code(this as Gen<T>, x)
    }
}

调用时必须显式指定或让编译器推导T的具体类型，确保后续操作的类型安全：

fun main() {
    val g: Gen<*> = Gen(String::class)
    
    // 正确调用：指定T为String，传入对应类型的参数
    g.ifMatches<String>("hello") { gen, str ->
        gen.doSomething(str) // 类型安全
        // gen.doSomething(8) // 编译失败，类型不匹配
    }
    
    // 错误调用会直接编译失败
    // g.ifMatches<String>(8) { ... }
    
    // 处理Any类型的x时，需要显式转型并指定T
    val x: Any = "hello"
    g.ifMatches<String>(x as String) { gen, str ->
        gen.doSomething(str)
    }
}

方案2：自动校验值类型的封装 #

如果需要直接处理Any类型的输入，可以在封装中同时验证值的类型，再安全转换：

inline fun <reified T : Any> Gen<*>.withMatchingValue(x: Any, code: (Gen<T>, T) -> Unit) {
    if (token.isInstance(x)) {
        code(this as Gen<T>, x as T)
    }
}

调用示例：

fun main() {
    val g: Gen<*> = Gen(String::class)
    val x: Any = "hello"
    
    g.withMatchingValue(x) { gen, str ->
        gen.doSomething(str) // 类型安全
        // gen.doSomething(8) // 编译失败
    }
    
    val y: Any = 8
    g.withMatchingValue(y) { _, _ ->
        // 这段代码不会执行，因为y不是String类型
    }
}

方案原理 #

• 利用reified类型参数，在函数内部可以直接获取T的KClass，和Gen的token做精确匹配。
• 通过isInstance检查确保输入值的类型合法性，避免了无意义的类型转换。
• 在token == T::class的前提下，this as Gen<T>的类型转换是绝对安全的——运行时检查已经验证了Gen的实际类型就是Gen<T>，只是编译器无法自动推导而已。

内容的提问来源于stack exchange，提问作者Werner Thumann