Kotlin: implementación de Function-Param en un cuerpo de un llamador

fun lazyProperty(initializer: () -> Int): Int { val result: Lazy<Int> = lazy(initializer) return result.value } fun main(args: Array<String>) { // 1. val bar: Int = lazyProperty({ 1 + 1 }) // 2. val foo: Int = lazyProperty() { 42 } println("bar $bar, foo: $foo") } 

Recientemente tropecé con la syntax de llamar a una function en Kotlin y simplemente no entiendo: la primera opción es clara: es una lambda, pero la segunda no se parece a la syntax habitual de llamar a una function con el parámetro requerido. Los paréntesis donde normalmente deberían colocarse los parameters están vacíos y en su lugar el parámetro de function viene en el cuerpo de la persona que llama. ¿Cómo es posible y para qué se necesita?

Esta es otra forma válida de pasar una lambda. De acuerdo con los documentos :

En Kotlin, existe la convención de que si el último parámetro para una function es una function, y está pasando una expresión lambda como el argumento correspondiente, puede especificarlo fuera de paréntesis:

 lock (lock) { shanetworkingResource.operation() } 

Puedes elegir el enfoque que prefieras.

Esto es solo una convención. Si el último parámetro de una function es una function, puede pasar la lambda fuera del paréntesis. En tu caso, tienes las siguientes opciones:

 val bar: Int = lazyProperty({ 1 + 1 }) val bar: Int = lazyProperty() { 1 + 1 } val bar: Int = lazyProperty { 1 + 1 } 

Las tres opciones son iguales.


Si su function tuviera un segundo parámetro (en la primera position), entonces las llamadas podrían verse así:

 fun lazyProperty(x: Int, initializer: () -> Int): Int {...} val bar: Int = lazyProperty(7, { 1 + 1 }) val bar: Int = lazyProperty(7) { 1 + 1 } 

Si su function tuviera un segundo parámetro (en la segunda position), entonces las llamadas podrían verse así:

 fun lazyProperty(initializer: () -> Int, x: Int): Int {...} val bar: Int = lazyProperty({ 1 + 1 }, 7) 

Intente mantener el Lambda en la última position de su function.