Lambdas

Hola tratando de comprender un poco mejor la sintaxis de la Lambda realicé este ejemplo:

Aunque no tiene que ver con Kotlin, pero si están aquí por la carrera de Android es muy recomendable ver el curso de Programación funcional con Java. https://platzi.com/clases/java-funcional/

Código de la clase 😃

fun main(args:Array<String>){
    val myLambda : (String) -> Int = {
        //it es el parametro que estamos pasando
        valor -> valor.length
    }
    val lambdaEjecutar = myLambda("David")
    println(lambdaEjecutar)

    val saludos = listOf("Hola","Ciao")
    val longitudSaludos = saludos.map(myLambda)
    println(longitudSaludos)
}

Lambdas:
Las conocemos en otros lenguajes como funciones anónimas o funciones literales

Funciones anónimas: lo declaramos una función que no tiene nombre
Una lambda es tan solo una forma de escribir una función, más simplificada

El uso de lambdas es muy util para operar listas en un map y no reptir el contenido de la operación.

Ejemplo:

fun main(args: Array<String>) {
	// declaración de lambda
	val myLambda: (String) -> Int = {
		valor -> valor.length
	}
	
	// invocar lambda y ejecutar.
	val lambdaEjecutado: Int = myLambda('hola platzi')
	println(lambdaEjecutado)
	
	// utilizar la lambda, esto es muy util cuando quieres hacer una operación en diferentes listas, para no estar repitiendo código.
	val saludos = ListOf('Hello', 'Hola', 'Ciao')
	val longitudDeSaludos = saludos.map(myLambda)
}

Ejemplos de declaración de Lambdas:

//Una lambda con tipos explícitos en todas partes. La lambda es la parte entre llaves, que se asigna a una variable de tipo (String) -> String (un tipo de función)
val upperCase1: (String) ->String={str: String -> str.uppercase()}

//Inferencia de tipo dentro de lambda: el tipo del parámetro lambda se infiere del tipo de variable a la que está asignado.
    val upperCase2: (String) -> String = {str -> str.uppercase()}

//Inferencia de tipo fuera de lambda: el tipo de variable se infiere del tipo del parámetro lambda y el valor de retorno.
    val upperCase3 = {str: String -> str.uppercase()}

//No puede hacer ambas cosas a la vez, el compilador no tiene la posibilidad de inferir el tipo de esa manera.
    //val upperCase4: {str -> str.uppercase()}



//Para lambdas con un solo parámetro, no tiene que nombrarlo explícitamente. En su lugar, puede utilizar la variable it implícita. Esto es especialmente útil cuando se puede inferir el tipo (que suele ser el caso).
    val upperCase5: (String) -> String = {it.uppercase()}

//Si su lambda consta de una única llamada de función, puede usar punteros de función (: :).
    val upperCase6: (String) -> String = String::uppercase

    println(upperCase1("hello"))
    println(upperCase2("hello"))
    println(upperCase3("hello"))
    println(upperCase5("hello"))
    println(upperCase6("hello"))

Salida:

Lambdas
Las Lambdas son una expresion que hace una funcion y decimos que no tiene nombre.
{println(“Hola Mundo”)}
var hola = {println(“Hola Mundo”)}
hola()

Las funciones lambda (“lambdas”) son una forma sencilla de crear funciones ad-hoc (para un fin determinado). Las lambdas se pueden denotar de forma muy concisa en muchos casos gracias a la inferencia de tipos y la variable it implícita.

Me parece favorable el uso de lambdas cuando queremos crear una función corta que haga alguna modificación en una lista, entero o string pasado. Con esto nos ahorramos tiempo de crear todo el cuerpo de una función tradicional.

val  MyLambda : (String) -> Int = {valor -> valor.length }
    val lambdaEjecutada: Int = MyLambda("hola")
    println(MyLambda)

    val saludos = listOf("Hello","Hola","Ciao")
    val longitudSaludos = saludos.map(MyLambda)

Es muy parecido a JavaScript 😯

A las lambdas también se le conocen como funciones anónimas

Las funciones lamda son como las expresiones Lamda en C# o las funciones anónimas en javascript, que son como quien dice, funciones en línea porque no se declaran, y están en línea con el código, cuando digo en línea me refiero a que es algo similar si lo quieren ver así, a los estilos CSS inline cuando se usa la etiqueta style que van ahora si dentro dentro de la misma línea donde va el elemento, y no son de bloque o declarados por fuera.

val eCount = "develou.com".count({ char:Char -> char == 'e' })
println(eCount)  //printn = 2

El predicado char -> char == ‘e’ se podría leer como «al parámetro char corresponde su resultado de igualdad con ‘e‘».

Si vas a la implementación de count(), verás que invoca nuestro lambda en un ciclo for:

Mi código 😃

// Lambdas
    val getLengthFromStringLambda : (String) -> Int = { value -> value.length }
    val someGreetingsInTheWorld = listOf(

	"Hello",
"Hola",
	"Ciao",
		"Bonjour", 
"Hallo",
 	"Olá", 
"Hej",
	 "Aloha", 
"Namaste", 
		"Salam", 
	"Ni Hao,"

)
    println(someGreetingsInTheWorld)
    // it automatically insert the string as lambda parameter
    val lengthOfSomeGreetingsInTheWorld = someGreetingsInTheWorld.map(getLengthFromStringLambda)
    println(lengthOfSomeGreetingsInTheWorld)

Encontré esta imagen que me ayudó a aclara la sintaxis de las Lambdas 😃