Generics 如何在kotlin中使用泛型编写lambda？

我可以用显式类型编写lambdas

id\u Int

和

id\u Boolean

。我可以用类型参数编写函数

identity

。我可以用类型参数写lambda吗

fun testFuncInt(f: (Int) -> Int): Int = f(1) + 2

val id_Int = { x: Int -> x }

fun testFuncBoolean(f: (Boolean) -> Boolean): Boolean = !f(false)

val id_Boolean = { x: Boolean -> x }

fun <T> identity(x: T) = x

fun main(args: Array<String>) {
    println(testFuncInt(id_Int))
    println(testFuncInt(::identity))
    println(testFuncBoolean(id_Boolean))
    println(testFuncBoolean(::identity))
}

有趣的testFuncInt（f：（Int）->Int:Int=f（1）+2 val id_Int={x:Int->x} 有趣的testFuncBoolean（f:（布尔）->布尔）：布尔=！f（假） val id_Boolean={x:Boolean->x} 有趣的身份（x:T）=x 趣味主线（args:Array）{ println（testFuncInt（id_Int）） println（testFuncInt（：：identity）） println（testFuncBoolean（id_Boolean）） println（testFuncBoolean（：：标识）） }

---

Kotlin不支持在不在类级别（）声明该类型的情况下声明泛型属性，但您可以使用返回与所需类型对应的lambda的函数来执行此操作：

fun main(args: Array<String>) {
    println(testFuncBoolean(id()))
    println(testFuncInt(id()))
}

fun <T> id(): (T) -> T = { it }

fun testFuncInt(f: (Int) -> Int): Int = f(1) + 2
fun testFuncBoolean(f: (Boolean) -> Boolean): Boolean = !f(false)

fun main（args:Array）{
println（testFuncBoolean（id（）））
println（testFuncInt（id（））
}
fun id（）：（T）->T={it}
有趣的testFuncInt（f：（Int）->Int）：Int=f（1）+2
有趣的testFuncBoolean（f:（布尔）->布尔）：布尔=！f（假）

你不能用泛型来编写lambda，为什么下面一段摘自官方文档的内容说明了一切

lambda表达式或匿名函数是“函数文字”，即未声明但立即作为表达式传递的函数

未声明lambda表达式或函数，它是匿名函数

但最终我们通过将函数类型声明为泛型来做同样的事情。我们可以传递一个lambda表达式来完成这项工作

fun testFuncInt(f: (Int) -> Int): Int = f(1) + 2 

您可以像这样调用它：

testFuncInt{a->a}

或

testFuncInt{it}

最后，您也在做同样的事情（lambda带有类型参数），但没有类似的术语，因为lambda是表达式或匿名函数

---

希望有帮助。

没有，但你通常不需要这样做。lambda并没有声明（这是一种点），所以它本质上是一个表达式，可以传递给一个函数，存储在一个

val

/

var

中，就像您在执行此操作时一样

val id_Boolean={x:Boolean->x}

但是，类型确实得到了计算，就像在表达式中一样

这里的调用将解析为正确的类型，因为您的函数接受一个接受

Int

并返回

Int

的函数，以及一个接受

Boolean

并返回

Boolean

testFuncInt({ x -> x }) // x is an Int
testFuncInt({ it })     // it is the default argument
testFuncInt { x -> x }  // as top one, Kotlin's syntactic sugar

这里重要的一点是lambda表达式仍然提供类型安全性，也就是说，如果您这样做

fun <T> foo(x: T, lambda: (T) -> Boolean): Boolean = lambda(x)
foo(42, { x -> x })   // oops, lambda takes a T and returns a T

---

返回类型实际上被推断为一个

布尔值

，因为这是比较操作的结果，并且123和42是同一类型，

lambda

的类型实际上符合

foo

的期望。

“Kotlin不支持类似泛型属性的东西”我会改变这句话的措辞，因为这句话是不正确的。不过，这是一个很好的解决方法。请注意，这不适用于

suspend

ing函数，因为它们必须是lambdas，而不是匿名函数。看见

foo(123, { it == 42 })
foo(123) { it == 42 }   // equivalent to above