Kotlin+Jetpack Compose：如何用多泛型与vararg实现通用可空值动画组件

你判断的没错，Kotlin目前无法直接通过vararg实现这种支持多个不同泛型可空参数、且能安全传递非空值给content lambda的需求，核心原因是vararg仅支持同类型（或兼容类型）的参数集合，无法保留多个独立泛型的类型信息，也无法在content中实现类型安全的参数传递。

不过有几种可行的替代方案可以满足你的需求：

1. 手动重载不同参数数量的版本 #

这是最直接且类型安全的方案，Jetpack Compose本身的很多组件（如Row、Column）也采用这种方式处理多参数场景。你可以针对2个、3个、4个参数分别实现重载版本：

示例：3个参数的重载实现 #

@Composable
fun <T1: Any, T2: Any, T3: Any> AnimatedVisibilityNullable(
    value1: T1?,
    value2: T2?,
    value3: T3?,
    visible: (T1, T2, T3) -> Boolean = { _, _, _ -> true },
    // 其他AnimatedVisibility的默认参数...
    content: @Composable (T1, T2, T3) -> Unit
) {
    val ref1 = remember { Ref<T1>() }
    val ref2 = remember { Ref<T2>() }
    val ref3 = remember { Ref<T3>() }

    LaunchedEffect(value1, value2, value3) {
        ref1.value = value1 ?: ref1.value
        ref2.value = value2 ?: ref2.value
        ref3.value = value3 ?: ref3.value
    }

    AnimatedVisibility(
        visible = value1 != null && value2 != null && value3 != null && visible(value1!!, value2!!, value3!!),
        // 传递其他AnimatedVisibility参数...
    ) {
        ref1.value?.let { p1 ->
            ref2.value?.let { p2 ->
                ref3.value?.let { p3 ->
                    content(p1, p2, p3)
                }
            }
        }
    }
}

优点：完全类型安全，调用时自动推导泛型，兼容Compose预览功能；
缺点：需要手动编写多个重载版本，参数数量受限于你实现的重载个数。

2. 用数据类封装多类型参数 #

将不同类型的可空参数封装到一个数据类中，然后基于这个数据类实现单个泛型的组件版本：

示例实现 #

// 定义参数封装类
data class VisibilityParams<T1: Any, T2: Any>(val value1: T1?, val value2: T2?)

@Composable
inline fun <T1: Any, T2: Any> AnimatedVisibilityNullable(
    params: VisibilityParams<T1, T2>,
    crossinline visible: (T1, T2) -> Boolean = { _, _ -> true },
    // 其他AnimatedVisibility的默认参数...
    crossinline content: @Composable (T1, T2) -> Unit
) {
    val ref1 = remember { Ref<T1>() }
    val ref2 = remember { Ref<T2>() }

    LaunchedEffect(params.value1, params.value2) {
        ref1.value = params.value1 ?: ref1.value
        ref2.value = params.value2 ?: ref2.value
    }

    AnimatedVisibility(
        visible = params.value1 != null && params.value2 != null && visible(params.value1!!, params.value2!!),
        // 传递其他AnimatedVisibility参数...
    ) {
        ref1.value?.let { p1 ->
            ref2.value?.let { p2 ->
                content(p1, p2)
            }
        }
    }
}

// 调用方式
AnimatedVisibilityNullable(VisibilityParams(user, post)) { user, post ->
    // 渲染内容
}

优点：无需编写多个重载，参数数量灵活；
缺点：调用时需要手动封装参数，代码略有繁琐。

为什么vararg不可行？ #

1. 类型限制：vararg要求所有参数属于同一类型（或其子类），无法同时传递User?、Post?这种不同泛型的参数；
2. 类型安全丢失：即使强行用vararg values: Any?接收参数，也无法在content lambda中以类型安全的方式获取不同类型的非空值，编译器无法推导每个参数的具体类型，只能得到Any类型，完全失去了泛型的意义。

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