如何在Kotlin中无需额外泛型参数特化EntityContainer的状态类型

我需要在Kotlin中实现特定的持久化逻辑，包装待持久化对象的同时，以类型安全的方式访问被包装泛型对象的state属性。现有代码结构如下：

sealed interface State

enum class StateA : State { A1, A2 } // 示例状态实现
enum class StateB : State { B1, B2 }

interface StatefulEntity {
    val state: State
}

// 示例实体；实际实体包含更多不同字段
data class EntityA(override val state: StateA, val otherField: String) : StatefulEntity
data class EntityB(override val state: StateB, val anotherField: Int) : StatefulEntity

// 包装实体用于持久化，同时提供state访问
data class EntityContainer<E: StatefulEntity>(
    private val entity: E,
    private val referenceId: String // 附加到实体的元数据
) {
    val state: State // 期望根据E的类型返回StateA或StateB
        get() = entity.state

    // 同样需要基于E的类型，接受对应具体State类型的参数
    fun updateState(state: State): EntityContainer<E> { 
        // 实现逻辑：创建新实体并返回新容器
        val newEntity = when(entity) {
            is EntityA -> entity.copy(state = state as StateA)
            is EntityB -> entity.copy(state = state as StateB)
            else -> throw IllegalArgumentException("不支持的实体类型")
        } as E
        return copy(entity = newEntity)
    }
}

核心问题：当指定EntityContainer的具体E类型后，E的state字段类型是确定的，但当前代码中state属性只能返回State超类型，无法直接以具体子类型访问。希望避免引入如下冗余泛型方案（该方案需要额外声明泛型参数，在其他场景会引发问题）：

interface StatefulEntity<S: State> { val state: S }

data class EntityContainer<E: StatefulEntity<S>, S: State>(
    private val entity: E,
    private val referenceId: String
) {
    val state: S get() = entity.state
    fun updateState(state: S): EntityContainer<E, S> {
        val newEntity = entity.copy(state = state) as E
        return copy(entity = newEntity)
    }
}

方案1：利用Kotlin契约（Contract）实现类型安全的状态访问 #

无需修改原有StatefulEntity接口，通过契约告知编译器state的具体类型，配合工具方法实现类型安全访问：

import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract

data class EntityContainer<E: StatefulEntity>(
    private val entity: E,
    private val referenceId: String
) {
    val state: State
        get() = entity.state

    // 类型安全的state获取方法
    @OptIn(ExperimentalContracts::class)
    inline fun <reified S : State> stateAs(): S {
        contract {
            returns() implies (entity.state is S)
        }
        return entity.state as S
    }

    fun updateState(newState: State): EntityContainer<E> {
        val newEntity = when (entity) {
            is EntityA -> entity.copy(state = newState as StateA)
            is EntityB -> entity.copy(state = newState as StateB)
            else -> throw IllegalArgumentException("不支持的实体类型")
        } as E
        return copy(entity = newEntity)
    }
}

使用示例：

val containerA = EntityContainer(EntityA(StateA.A1, "test"), "ref-001")
// 类型安全获取StateA，无需显式强转
val currentState: StateA = containerA.stateAs()
// 更新状态，传入StateA类型参数
val updatedContainer = containerA.updateState(StateA.A2)

方案2：为StatefulEntity添加状态更新接口（更优雅的类型安全） #

给StatefulEntity添加一个用于更新状态的方法，避免在EntityContainer中做类型判断：

interface StatefulEntity {
    val state: State
    // 定义更新状态的方法，子类实现时返回自身类型
    fun withState(newState: State): StatefulEntity
}

data class EntityA(override val state: StateA, val otherField: String) : StatefulEntity {
    override fun withState(newState: State): EntityA {
        return copy(state = newState as StateA)
    }
}

data class EntityB(override val state: StateB, val anotherField: Int) : StatefulEntity {
    override fun withState(newState: State): EntityB {
        return copy(state = newState as StateB)
    }
}

data class EntityContainer<E: StatefulEntity>(
    private val entity: E,
    private val referenceId: String
) {
    val state: State get() = entity.state

    @OptIn(ExperimentalContracts::class)
    inline fun <reified S : State> stateAs(): S {
        contract {
            returns() implies (entity.state is S)
        }
        return entity.state as S
    }

    fun updateState(newState: State): EntityContainer<E> {
        // 借助子类实现的withState方法，无需类型判断
        val newEntity = entity.withState(newState) as E
        return copy(entity = newEntity)
    }
}

方案说明 #

如果想要直接通过val state属性获取具体的State子类型，而无需调用工具方法，那么必须给StatefulEntity添加泛型参数（即你提到的“冗余”方案）。这并非冗余，而是让编译器在编译期明确state的具体类型，避免运行时类型转换的风险。如果无法接受该方案，上述两个方案可以在不修改原有StatefulEntity泛型结构的前提下，实现近似的类型安全访问。

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