如何在Kotlin中类型安全地转换结构相似的求和类型

问题背景 #

我们有两组结构对称的嵌套密封类型：

Node 类型体系 #

sealed interface Node
data class Values(val data: String) : Node
data class Container<V : Node>(val nodes: Map<String, V>) : Node

可构造出 Container<Container<Values>> 这类深度嵌套的结构。

Diff 类型体系 #

sealed interface Diff
data class ValuesDiff(val data: String) : Diff
data class ContainerDiff<V : Diff>(val nodes: Map<String, V>) : Diff

需求是类型安全地将任意嵌套的Node结构转换为对应的Diff结构，例如把 Container<Container<Values>> 转为 ContainerDiff<ContainerDiff<ValuesDiff>>。

Scala 3的Match Types可优雅实现这类递归类型映射，但Kotlin中有没有对应方案？

当前尝试给Diff添加关联Node的泛型参数：

sealed interface Diff<T : Node>
data class ValuesDiff(val data: String) : Diff<Values>
data class ContainerDiff<V : Node>(val nodes: Map<String, Diff<V>>) : Diff<Container<V>>

但访问嵌套Diff时，编译器无法自动推导具体子类类型，必须用显式Cast：

val myDiff: ContainerDiff<Container<Values>> = ContainerDiff(
    mapOf("inner" to ContainerDiff(mapOf("value" to ValuesDiff("test"))))
)
// 编译器仅能推断为Diff<Container<Values>>，实际类型是ContainerDiff<Values>
val theFirstContainer: Diff<Container<Values>> = myDiff.nodes.values.first()

// 不得不定义Cast扩展
fun Diff<Values>.cast() = this as ValuesDiff
fun <V : Node> Diff<Container<V>>.cast() = this as ContainerDiff<V>

// 依赖Cast才能获取具体类型
val castedContainer: ContainerDiff<Values> = theFirstContainer.cast()
val castedValue: ValuesDiff = castedContainer.nodes.values.first().cast()

请问有没有无需显式Cast就能直接获取目标具体类型的实现方案？

解决方案：密封类智能转换 + 递归类型映射 #

Kotlin虽无Scala 3的Match Types，但可通过密封类智能转换结合递归类型转换扩展，让编译器自动推导具体类型，完全避免显式Cast。

1. 保留泛型关联的Diff定义 #

先保留带泛型的Diff结构，这是类型关联的基础：

sealed interface Diff<T : Node>
data class ValuesDiff(val data: String) : Diff<Values>
data class ContainerDiff<V : Node>(val nodes: Map<String, Diff<V>>) : Diff<Container<V>>

2. 递归的Node转Diff扩展函数 #

给Node添加toDiff()扩展函数，利用密封类的when表达式智能转换，递归处理嵌套结构：

inline fun <reified T : Node> T.toDiff(): Diff<T> = when (this) {
    is Values -> ValuesDiff(this.data) as Diff<T>
    is Container<*> -> ContainerDiff(
        this.nodes.mapValues { (_, node) -> node.toDiff() }
    ) as Diff<T>
}

这里reified关键字让函数内部能获取T的具体类型，结合when分支的智能转换，内部的as转换是编译期安全的，无需担心类型错误。

3. 安全访问嵌套Diff的具体类型 #

通过toDiff()得到Diff实例后，可直接用when表达式进行智能转换，无需Cast：

val node: Container<Container<Values>> = Container(
    mapOf("inner" to Container(mapOf("value" to Values("test"))))
)

// 精确获取对应类型的Diff
val diff: ContainerDiff<Container<Values>> = node.toDiff()

// 访问内部Diff时，用when智能转换
val innerDiff = diff.nodes.values.first()
when (innerDiff) {
    is ContainerDiff<*> -> {
        // 自动推导为ContainerDiff<Values>
        val valueDiff = innerDiff.nodes.values.first()
        when (valueDiff) {
            is ValuesDiff -> println(valueDiff.data) // 直接访问字段，无Cast
        }
    }
}

进阶优化：封装安全转换扩展 #

若不想重复写when表达式，可给Diff添加扩展函数，利用泛型约束封装安全转换：

// 因Diff<Values>仅能由ValuesDiff实现，此转换绝对安全
fun Diff<Values>.asValuesDiff(): ValuesDiff = this as ValuesDiff

// 同理，Diff<Container<V>>仅能由ContainerDiff<V>实现
fun <V : Node> Diff<Container<V>>.asContainerDiff(): ContainerDiff<V> = this as ContainerDiff<V>

使用时直接调用扩展函数即可：

val innerDiff: Diff<Container<Values>> = diff.nodes.values.first()
val containerDiff = innerDiff.asContainerDiff() // 直接得到ContainerDiff<Values>
val valueDiff = containerDiff.nodes.values.first().asValuesDiff() // 直接得到ValuesDiff

核心原理 #

1. 密封类排他性：密封接口的子类固定，结合泛型参数的对应关系，每个Diff<T>的具体类型唯一，保证转换安全。
2. 智能转换：when表达式中，编译器自动将密封类型实例转为对应子类，无需显式Cast。
3. 具体化泛型：reified让泛型函数能获取具体类型，实现精确的递归类型映射。

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