Kotlin中如何在Lambda中使用多个泛型类型？

你猜得太准了！问题的核心就是泛型没有添加必要的类型约束——Kotlin无法推断泛型T是否支持+操作（比如如果T是Boolean或者自定义的无加法逻辑的类，这段代码完全不合理），所以直接写num1 + num2会报错。下面给你几个实用的实现方案，覆盖不同业务场景：

先回顾你的代码 #

可正常运行的无泛型版本：

fun onScanExt(): (Int, Int) -> Int = { num1, num2 -> num1 + num2 }

报错的泛型版本：

fun <T, R> onScanExt(): (T, T) -> R = { num1, num2 -> num1 + num2 }

方案1：将加法逻辑作为参数传入（最灵活） #

如果你的Lambda需要支持多种类型的"相加"（比如数值加法、字符串拼接、自定义对象合并），最好把具体的操作逻辑作为参数传入，让泛型的行为明确：

// 定义泛型函数，接收一个处理两个T类型参数返回R类型的Lambda
fun <T, R> onScanExt(operation: (T, T) -> R): (T, T) -> R = operation

// 使用示例1：Int类型加法
val intAdder = onScanExt<Int, Int> { a, b -> a + b }
println(intAdder(3, 5)) // 输出：8

// 使用示例2：String类型拼接
val stringConcat = onScanExt<String, String> { a, b -> a + b }
println(stringConcat("Hello", " Kotlin")) // 输出：Hello Kotlin

// 使用示例3：自定义对象合并（比如合并两个用户的积分）
data class User(val name: String, val score: Int)
val mergeUserScores = onScanExt<User, Int> { u1, u2 -> u1.score + u2.score }
println(mergeUserScores(User("Alice", 100), User("Bob", 200))) // 输出：300

方案2：给泛型添加类型约束（限定为可相加类型） #

如果你的场景只需要处理数值类型，可以给T添加Number的约束，同时处理不同数值类型的加法：

// 限定T为Number子类，返回值R也为Number子类
fun <T : Number, R : Number> onScanExt(): (T, T) -> R {
    return { num1, num2 ->
        // 根据实际类型处理加法，可扩展更多类型
        when {
            num1 is Int && num2 is Int -> (num1 + num2) as R
            num1 is Double && num2 is Double -> (num1 + num2) as R
            num1 is Float && num2 is Float -> (num1 + num2) as R
            else -> throw IllegalArgumentException("Unsupported number type: ${num1.javaClass.name}")
        }
    }
}

// 使用示例
val intCalculator = onScanExt<Int, Int>()
println(intCalculator(10, 20)) // 输出：30

val doubleCalculator = onScanExt<Double, Double>()
println(doubleCalculator(1.5, 2.7)) // 输出：4.2

方案3：利用Kotlin类型推导简化代码 #

如果不想显式指定泛型类型，可以借助Kotlin的自动类型推导，让代码更简洁：

// 定义泛型扩展函数，自动推导参数和返回值类型
fun <T, R> ((T, T) -> R).asScanExt(): (T, T) -> R = this

// 使用示例：无需显式指定泛型，编译器自动推断
val floatAdder = { a: Float, b: Float -> a + b }.asScanExt()
println(floatAdder(2.3f, 4.5f)) // 输出：6.8

val longAdder = { a: Long, b: Long -> a + b }.asScanExt()
println(longAdder(100L, 200L)) // 输出：300

关键建议 #

• 永远给泛型加必要约束：避免使用无边界的泛型（比如<T, R>），否则编译器无法知道类型的操作能力，会导致编译错误。
• 优先抽离可变逻辑：如果泛型的操作逻辑不固定，把逻辑作为参数传入比硬编码更灵活，能覆盖更多场景。
• 利用类型推导减少冗余：Kotlin的类型推导能力很强，尽量让编译器自动推断泛型类型，减少显式指定的代码。

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