High Order functions

Básicamente entendí que las funciones lambda son funciones que se pueden enviar como parámetro a otras funciones. Esto por que los parámetros de una función pueden variar en función de un dato.

fun main() {
//High-Order Function
    val resultHighOrder = addTwoNum(myLambdaFunc(2,2),myLambdaFunc(2,2))
    print(resultHighOrder) // result = 8
}
//{x, y-> x + y} Lambda: A function without name
fun addTwoNum(x: Int, y: Int):Int{ //Parameters
    return x + y //Method Body
}
//Lambda Expression
val myLambdaFunc: (Int, Int)-> Int = {x, y-> x + y}

En esta clase si que quedé boludo!

pues esto es un callback ¿no?

La variable lambda se convierte en una Lambda heredando el tipo de input y return de funtionInception()

fun main() {
    val lambda : () -> String = funtionInception("Chair")
    println(lambda())
    // Consola = Objet from Lambda: Chair
}

fun funtionInception(name : String) : () -> String {
    return {"Objet from Lambda: $name"}
}

fun main() {
    val lambda = funtionInception(7)
    println(lambda(2))  //Consola = 3.5
}

fun funtionInception(number : Int) : (Int) -> Double {
    return {divider -> number.toDouble()/divider.toDouble()}
}

Código de la clase

fun main(args: Array<String>){
    var largoValorInit = superFunction(valorInit = "Hola", block = {
        it.length
    })
    println(largoValorInit)

    val lambda = functionInception("David")
    println(lambda())
}

fun superFunction (valorInit: String, block : (String)->Int) :Int {
    return block(valorInit)
}

fun functionInception (nombre:String): () -> String {
    return{
        "Hola"+" "+nombre
    }
}

ese tipo solo le importa que algunos entienda

Block es una sintaxis recomendada por kotlin para nombrar las lambdas, puedes nombrar block cuando vas a ejecutar un codigo o la puedes llamar event o listener cuando vas a realizar una acción dependiendo de un evento

Genial estos cursos!

Función de orden superior –

• En Kotlin, una función que puede aceptar una función como parámetro o puede devolver una función se llama función de orden superior . En lugar de Integer, String o Array como parámetro para funcionar, pasaremos una función anónima o lambdas. Con frecuencia, las lambdas se pasan como parámetro en las funciones de Kotlin por conveniencia.

-Pasar la expresión lambda como parámetro a la función de orden superior:
Podemos pasar una expresión lambda como parámetro a la función de orden superior.
Hay dos tipos de expresiones lambda que se pueden pasar:

• Expresión lambda que devuelve Unidad
• Expresión lambda que devuelve cualquiera de los valores enteros, cadenas, etc.

 // lambda expression
var lambda = {println("GeeksforGeeks: A Computer Science portal for Geeks") }
      // higher-order function
fun higherfunc( lmbd: () -> Unit ) {     // accepting lambda as parameter
    lmbd()                               //invokes lambda expression
}
fun main(args: Array<String>) {
     //invoke higher-order function
    higherfunc(lambda)                 // passing lambda as parameter

Explicación:
comprendamos el programa anterior paso a paso:
en la parte superior, definimos una expresión lambda que contiene print() para imprimir una cadena en la salida estándar.

var lambda = {println("GeeksforGeeks: un portal de informática para geeks") }

luego, definimos una función de orden superior que contiene un parámetro.

lmbd: () -> Unidad

lmbd es el nombre local del parámetro lambda de recepción.
() representa que la función no acepta ningún argumento.
La unidad representa que la función no devuelve ningún valor.
En la función principal, hemos invocado la función de orden superior pasando la expresión lambda como parámetro.

función superior (lambda)

dejo mi aporte, me sirvio para practicar y entender la dinamica de la HOF:
Es una funcion que retorna una funcion. Recibe de parametro un nombre, lo busca en el map e imprime su valor. Si no esta el nombre ingresado, como el de Lisa, imprime un mensaje acorde.

Prestem atemcopm al return de la funcion generarFraseSimpsons, lo que devuelve esta entre llaves porque debe ser una lambda. Ii sacamos esas llaves, lo que devuelve seria un String, y no seria lo que necesitamos.

fun main(args: Array<String>) {
    // High Order function == retorna una funcion
    val fraseHomero: () -> String = generarFraseSimpsons("homero")
    // opcion 1
    println(fraseHomero) // Function0<java.lang.String>
    println(fraseHomero())
    // opcion 2
    val valorFraseHomero: String = fraseHomero()
    println(valorFraseHomero)

    val fraseJimbo = generarFraseSimpsons("jimbo")
    println(fraseJimbo())

    val fraseLisa = generarFraseSimpsons("lisa")
    println(fraseLisa())
}

val mapaFrases = mutableMapOf(
    "homero" to "a la grande le puse cuca...",
    "bart" to "comete mis calzones",
    "jimbo" to "chupame el pie skinner",
    "skinner" to "no no no! dije hamburguejas, hamburguejas al vapor!"
)

fun generarFraseSimpsons(nombre: String): () -> String {
    return {
        if (mapaFrases.contains(nombre)) {
            "Frase de $nombre : ${mapaFrases[nombre]} "
        } else {
            "No tenemos frase para $nombre"
        }
    }
} 



output:
Function0<java.lang.String>
Frase de homero : a la grande le puse cuca... 
Frase de homero : a la grande le puse cuca... 
Frase de jimbo : chupame el pie skinner 
No tenemos frase para lisa

Me gustaría que escribiesen la redacción de este curso, o se dice todo en inglés, o se dice todo en español.
El “Espanglish” como lo conocemos en México es pésimo cuando le enseñas a alguien un concepto literal.

Un ejemplo de una función de orden superior, que toma una función como parámetro

/*--------------TOMANDO FUNCIONES COMO PARÁMETROS-----------------*/

//Declarando un función de orden superior. Toma dos parámetros, x e y.
//Adicionalmente toma otra función como parámetro.
//Los parámetros de operación y el tipo de retorno también se definen en la declaración
fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    //La función de orden superior devuelve el resultado de la invocación de la operación con los argumentos proporcionados
    return operation(x, y)
}

//Declara una función que coincide con la firma de la operación
fun sum(x: Int, y: Int) = x + y

fun main() {
    //Invoca la función de orden superior pasando dos valores enteros y el argumento de la función ::suma
    //:: es la notación que hace referencia a una función por su nombre en Kotlin.
    val sumResult = calculate(4, 5, ::sum)

    //Invoca la función de orden superior pasando un lambda como argumento de función.
    val mulResult = calculate(4, 5) { a, b -> a * b }
    println("sumResult $sumResult, mulResult $mulResult")

Las funciones de orden superior son funciones que reciben como parametro a otras funciones, esto es un “template” o la forma mas generica de definir una funcion de orden superior.

Mas info aqui

fun main(args: Array<String>){
    var largoValorInit = superFunction(valorInit = "Hola", block = {
        it.length
    })
    println(largoValorInit)

    val lambda = functionInception("David")
    println(lambda())
}

fun superFunction (valorInit: String, block : (String)->Int) :Int {
    return block(valorInit)
}

fun functionInception (nombre:String): () -> String {
    return{
        "Hola"+" "+nombre
    }
}