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

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:

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)
}

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.

Una cuestión sintactica no menor, a mi entender, es que las lambdas no son pasadas o usadas como “parametro” sino que son pasadas o usadas como “argumento”.

La diferencia radica en que parametro es la variable definida en una declaración de función mientras que argumento es el valor realmente pasado cuando se llama a esta función. Así es que:

package parametrosYArgumentos

fun main() {
    imprimirNombre(nombre = "Mariano", segundoNombre = "Daniel", apellido = "Gobea") // Argumentos
}

fun imprimirNombre (nombre: String, segundoNombre: String = "", apellido: String) { // Parametros 
    println("Mi nombre completo es $nombre $segundoNombre $apellido")
}

Espero sirva a la aclaración y que lo corrijan en el curso. Gracias!

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)

Una lambda en Kotlin es una función anónima que puede ser tratada como un objeto. Se utiliza principalmente para crear funciones de orden superior, es decir, funciones que pueden recibir otras funciones como parámetros o devolverlas como resultado. Una lambda se compone de una lista de parámetros opcionales, una flecha “->” y un cuerpo de función.

Tambien se pudo haber ejecutado la funcion dentro del print de la siguiente manera:

println(myLambda("Hola"))

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)

no son como las arrow functions de JavaScript?

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:

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

Una función lambda es un literal de función que puede ser usado como expresión. Esto quiere decir, una función que no está ligada a un identificador y que puedes usar como valor.

Por ejemplo, si tenemos la función f(s) = s + 2, en Kotlin podemos expresarla como una declaración de función separada, así:

fun sumarDos(s: Int) = s + 2
Al ser reescrita como lambda, tendrías lo siguiente:

{s:Int -> s + 2}
Definir la función de esta forma te permitirá usarla como un valor en diferentes situaciones, como pasarla como argumento de una función o almacenarla en una variable.

La sintaxis de un literal lambda va al interior de dos llaves {}. Sus componentes son:

Lista de parámetros — Cada parámetro es una declaración de variable, aunque esta lista es opcional
Operador de flecha -> — Se omite si no usas lista de parámetros
Cuerpo del lambda — Son las sentencias que van luego del operador de flecha
Sintaxis De Expresiones Lambda En Kotlin
La anterior sintaxis de la imagen se puede leer como «para cada par de s y t corresponde el valor 2*(s+t)«