Trabajar con la función anónima en Kotlin

En Kotlin, podemos tener funciones como expresiones creando lambdas. Las lambdas son funciones literales, es decir, no se declaran como expresiones y se pueden pasar como parámetros. Sin embargo, no podemos declarar tipos de devolución en lambdas. Aunque el compilador de Kotlin infiere automáticamente el tipo de valor devuelto en la mayoría de los casos, para los casos en los que no se puede inferir por sí solo o debe declararse explícitamente, usamos las funciones anónimas. En este artículo, veremos cómo usar las funciones anónimas. Antes de eso tenemos algunos:

Requisitos previos para este artículo:

• Funciones en Kotlin

Idea básica de estos:

• Expresión lambda (es una forma corta de definir una función).
• Función anónima (es una forma alternativa de definir una función).

Consulte este artículo: Expresiones lambdas y funciones anónimas

Ejemplo

Aprenderemos sobre las funciones anónimas paso a paso con la ayuda de algunos ejemplos:

Comencemos declarando una función como lambda:

fun main(args: Array<String>){
    val funMultiply = {a : Int, b : Int-> a * b} 
    printIn(funMultiply(6,4))
    val funSayHi = {name : String->println("Hi $name")}
    funSayHi("geek")
}

En el bloque de código anterior, hemos declarado dos lambdas: una (funMultiply) que toma dos números enteros y devuelve un número entero, y otra lambda (funSayHi) que toma una string y devuelve una unidad, es decir, no devuelve nada. Aunque en el ejemplo anterior no necesitábamos declarar el tipo de argumentos y el tipo de devolución, en algunos casos necesitamos declarar explícitamente los tipos de argumento y los tipos de devolución. Lo hacemos de la siguiente manera, por medio de una función anónima:

fun main (args: Array<String>){
  var funMultiply = fun (a: Int, b: Int) : Int {return a*b}
  printin (funMultiply (6,4))
  fun (name : String) : Unit = println ("Hi $name")
}

Así que ahora tenemos una idea general de cómo funcionan las funciones anónimas. Ahora, intentemos pasar uno en otra función, es decir, intentaremos una función de orden superior. Echa un vistazo a este fragmento de código:

fun main (args: Array<String>){
    var funMultiply = fun(a: Int, b: Int) : Int { return a*b }
    var funSum = fun(a: Int, b: Int) : Int { return a+b }
    performMath (6, 4, funMultiply)
    performMath (6, 4, funSum)
}
fun performMath (a : Int, b: Int, mathFun : (Int, Int) -> Int) : Unit
{
    printIn ( "Value of calculation: ${mathFun(a, b)}")
}

Básicamente, una función anónima se declara como una función normal, pero sin nombre. El cuerpo puede ser una expresión, como en el ejemplo siguiente, o un bloque, como en el ejemplo anterior. Una cosa a tener en cuenta es que los parámetros siempre se pasan entre paréntesis en el caso de funciones anónimas, a diferencia de las expresiones lambda:

fun main (args: Array<String>) {
    performMath (6,4, fun (a: Int, b: Int) : Int = a*b )
    performMath (6,4, fun (a: Int, b: Int) : Int = a+b )
}
fun performMath (a : Int, b: Int, mathFun : (Int, Int) -> Int) : Unit
{
    println ("final value: ${mathFun(a,b)}")
}

• Otra diferencia interesante entre una lambda y una función anónima es que en una lambda, la declaración de retorno regresa de la función que la encierra, mientras que en una función anónima, simplemente regresa de la función misma.
• También se puede omitir el tipo de parámetro y el tipo de retorno de una función anónima si se puede inferir por sí solo.
• Las funciones anónimas pueden acceder y modificar variables dentro de sus cierres.

Básicamente, uno puede declarar una función anónima como una función regular sin nombre (de ahí el nombre anónimo). Puede ser una expresión o un bloque de código.