Kotlin | Expresiones lambdas y funciones anónimas

En este artículo, vamos a aprender la expresión lambdas y la función anónima en Kotlin. Si bien son similares sintácticamente, Kotlin y Java lambdas tienen características muy diferentes. 

La expresión lambdas y la función anónima son funciones literales , lo que significa que estas funciones no se declaran, sino que se pasan inmediatamente como una expresión. 

Expresión lambda –

Como sabemos, la sintaxis de Kotlin lambdas es similar a Java Lambdas. Una función sin nombre se llama función anónima. Para la expresión lambda podemos decir que es una función anónima.

Ejemplo: 

fun main(args: Array<String>) {
    val company = { println("GeeksforGeeks")}
 
    // invoking function method1
    company() 
 
    // invoking function method2
    company.invoke()
}

Producción: 

GeeksforGeeks
GeeksforGeeks

Sintaxis de la expresión Lambda – 

val lambda_name : Data_type = { argument_List -> code_body }

Una expresión lambda siempre está rodeada de llaves, las declaraciones de argumentos van dentro de llaves y tienen anotaciones de tipo opcionales, el cuerpo del código va después de una flecha -> signo. Si el tipo de devolución inferido de la lambda no es Unidad, la última expresión dentro del cuerpo de lambda se trata como valor de devolución.

Ejemplo: 

val sum = {a: Int , b: Int -> a + b}

En Kotlin, la expresión lambda contiene una parte opcional excepto code_body. A continuación se muestra la expresión lambda después de eliminar la parte opcional. 

val sum:(Int,Int) -> Int = { a, b -> a + b}

Nota: No siempre requerimos una variable porque se puede pasar directamente como argumento a una función.

Programa Kotlin de usar expresión lambda-  

// with type annotation in lambda expression
val sum1 = { a: Int, b: Int -> a + b }
 
// without type annotation in lambda expression
val sum2:(Int,Int)-> Int  = { a , b -> a + b}
 
fun main(args: Array<String>) {
    val result1 = sum1(2,3)
    val result2 = sum2(3,4)
    println("The sum of two numbers is: $result1")
    println("The sum of two numbers is: $result2")
 
    // directly print the return value of lambda
    // without storing in a variable.
    println(sum1(5,7))
}

Producción: 

The sum of two numbers is: 5
The sum of two numbers is: 7
12

Escriba la inferencia en lambdas-

La inferencia de tipos de Kotlin ayuda al compilador a evaluar el tipo de una expresión lambda. A continuación se muestra la expresión lambda con la que podemos calcular la suma de dos números enteros.  

val sum = {a: Int , b: Int -> a + b}

Aquí, el compilador de Kotlin lo autoevalúa como una función que toma dos parámetros de tipo Int y devuelve el valor Int. 

(Int,Int) -> Int

Si quisiéramos devolver el valor de string, podemos hacerlo con la ayuda de la función incorporada toString(). 

val sum1 = { a: Int, b: Int ->
    val num = a + b
    num.toString()     //convert Integer to String
}
fun main(args: Array<String>) {
    val result1 = sum1(2,3)
    println("The sum of two numbers is: $result1")
}

Producción: 

The sum of two numbers is: 5

En el programa anterior, el compilador de Kotlin lo evalúa automáticamente como una función que toma dos valores enteros y devuelve una string. 

(Int,Int) -> String  

Declaración de tipo en lambdas –

Debemos declarar explícitamente el tipo de nuestra expresión lambda. Si lambda no devuelve ningún valor, podemos usar: Patrón de unidad  : (Entrada) -> Salida

Ejemplos de Lambdas con tipo de retorno –  

val lambda1: (Int) -> Int = (a -> a * a)
val lambda2: (String,String) -> String = { a , b -> a + b }
val lambda3: (Int)-> Unit = {print(Int)}

Lambdas se puede utilizar como extensión de clase:  

val lambda4: String.(Int) -> String = {this + it} 

Aquí, representa el nombre implícito de un solo parámetro y lo discutiremos más adelante.

Programa Kotlin cuando se usan lambdas como extensión de clase –  

val lambda4 : String.(Int) -> String = { this + it }
 
fun main(args: Array<String>) {
    val result = "Geeks".lambda4(50)
    print(result)
}

Producción: 

Geeks50

Explicación: 
En el ejemplo anterior, estamos usando la expresión lambda como extensión de clase. Hemos pasado los parámetros de acuerdo con el formato dado anteriormente. esta palabra clave se usa para la string y la palabra clave se usa para el parámetro Int pasado en la lambda. Luego, code_body concatena ambos valores y regresa al resultado variable. 

it: nombre implícito de un único parámetro –

En la mayoría de los casos, lambdas contiene el parámetro único. Aquí, se usa para representar el único parámetro que pasamos a la expresión lambda.

Programa Kotlin usando la forma abreviada de la función lambda –  

val numbers = arrayOf(1,-2,3,-4,5)
 
fun main(args: Array<String>) {
      println(numbers.filter {  it > 0 })
}

Producción: 

[1, 3, 5]

Programa Kotlin usando la forma manual de la función lambda – 

val numbers = arrayOf(1,-2,3,-4,5)
 
fun main(args: Array<String>) {
     println(numbers.filter {item -> item > 0 })
}

Producción: 

[1, 3, 5] 

Devolviendo un valor de la expresión lambda –

Después de la ejecución de lambda, el valor final devuelto por la expresión lambda. La función lambda puede devolver cualquiera de estos valores enteros, de string o booleanos.

Programa Kotlin para devolver el valor de string mediante la función lambda –  

val find =fun(num: Int): String{
if(num % 2==0 && num < 0) {
    return "Number is even and negative"
   }
    else if (num %2 ==0 && num >0){
    return "Number is even and positive"
    }
    else if(num %2 !=0 && num < 0){
    return "Number is odd and negative"
    }
    else {
    return "Number is odd and positive"
    }
}
fun main(args: Array<String>) {
    val result = find(112)
    println(result)
}

Producción: 

Number is even and positive

Función anónima

Una función anónima es muy similar a una función regular excepto por el nombre de la función que se omite en la declaración. El cuerpo de la función anónima puede ser una expresión o un bloque.

Ejemplo 1: Cuerpo de función como expresión  

fun(a: Int, b: Int) : Int = a * b

Ejemplo 2: Cuerpo de función como bloque 

fun(a: Int, b: Int): Int {
    val mul = a * b
    return mul
}

Tipo de retorno y parámetros- 

1. El tipo de devolución y los parámetros también se especifican de la misma manera que para la función normal, pero podemos omitir los parámetros si se pueden inferir del contexto.
2. El tipo de retorno de la función puede deducirse automáticamente de la función si es una expresión y debe especificarse explícitamente para la función anónima si es un bloque de cuerpo.

Diferencia entre expresiones lambda y funciones anónimas
: la única diferencia es el comportamiento de los retornos no locales. Una declaración de retorno sin etiqueta siempre regresa de la función declarada con la palabra clave fun. Esto significa que un retorno dentro de una expresión lambda regresará desde la función adjunta, mientras que un retorno dentro de una función anónima regresará desde la propia función anónima.

programa Kotlin para llamar a la función anónima-  

// anonymous function with body as an expression
val anonymous1 = fun(x: Int, y: Int): Int = x + y
 
// anonymous function with body as a block
val anonymous2 = fun(a: Int, b: Int): Int {
            val mul = a * b
            return mul
            }
fun main(args: Array<String>) {
    //invoking functions
    val sum = anonymous1(3,5)
    val mul = anonymous2(3,5)
    println("The sum of two numbers is: $sum")
    println("The multiply of two numbers is: $mul")
}

Producción: 

The sum of two numbers is: 8
The multiply of two numbers is: 15