Function Types

Me parece que en el ejercicio de la función como parámetro en la línea 141 (05:47) esta equivocada la invocación pues hace invocación a mathFunction que es una variable global anterior y no precisamente al parámetro mathFunc que es la función-parámetro que realmente se debería invocar para que lo que se pase a printMathResult si cambie dado el parámetro sino el resultado siempre será el mismo sin importar como se invoque

Cuando vi como pasaba una función como parámetro me recordó mucho a los callbacks en JS 😊

🤯

Yo hice una calculadora muy sencilla. Para reafirmar el concepto.

Interesante. Siento que debo repasar bien esto de las funciones ya que 🤯. Pero encantada con lo que ofrece Swift 👍🏻😁

Se podría crear un typealias para simplificar un poco la legibilidad:

typealias MathFn = (Int, Int) -> Int

func printMathResult(_ mathFn: MathFn, _ a: Int, _ b: Int) -> Void {
    print("El resultado de la operación es \(mathFn(a, b))")
}

printMathResult(multiplyTwoInts, 4, 5)

que bonita clase 😦

// Function Types:
func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a+b
}// esto es del tipo (Int, Int) -> Int
func multiplyInts(_ a: Int, _ b: Int) -> Int {
    return a*b
}// esto es del tipo (Int, Int) -> Int
func printHW(){
    print("Hello world!")
}// () -> Void


var mathFunction: (Int, Int) -> Int = addTwoInts

mathFunction(4,5)

// esto permite:
func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int){
    print("Resultado: \(mathFunction(a,b))")
}

printMathResult(mathFunction, 5, 6)




// otro ejemplo:
func stepForward(_ input: Int) -> Int{
    return input + 1
}
func stepBackward(_ input: Int) -> Int{
    return input - 1
}

func chooseStepFunction(backward: Bool) -> (Int) -> Int{
    //es lo mismo:
//    if backward{
//        return stepForward
//    }else{
//        return stepForward
//    }
    return backward ? stepBackward : stepForward
}

var value = 7
let moveNearerZero = chooseStepFunction(backward: value > 0)
// entonces moveNearerZero va a tomar la función: stepBackward
while value != 0{
    print("\(value)...")
    value = moveNearerZero(value)
}

Funciones de primer orden, me hace recordar Haskell… Muy bueno…

//Ejemplo
var mathFunction : (Int, Int) -> Int = multiplyTwoInts
mathFunction(4,5)

func printMathResult(_ mathFunc: (Int, Int) -> Int, _ a:Int, _ b: Int){
    print("Resultado: \(mathFunction(a,b))")
}

printMathResult(multiplyTwoInts, 5, 9)

//Ejemplo
func stepForward(_ input: Int) -> Int {
    return input + 1
}

func stepBackward(_ input: Int) -> Int {
    return input - 1
}

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    return backward ? stepBackward : stepForward
}

var valueNumber = 7
let moveNearerZero = chooseStepFunction(backward: valueNumber > 0)

while valueNumber != 0 {
    print("\(valueNumber)...")
    valueNumber = moveNearerZero(valueNumber)
}
print("Cero!!!!!")

🤯

Que buena clase, asi si se disfruta una clase de programación con un nivel de complejidad mayor

Cualquier parecido con Typescript y JS es pura coincidencia 😅

🤯
Nah, muy parecido a JS pero más bonito jejeje

Mi función reguapa que hace la cuenta atrás y además es inout 😄

func countDown(_ value: inout Int) {
    var moveNearerZero = chooseStepFunction(backward: value > 0)
    while value != 0 {
        print("\(value)...")
        value = moveNearerZero(value)
    }
    print("Zero!!!")
}

var value = -7
countDown(&value)
print(value)

Despues de repetir la clase, logre entender el concepto. Un dolor de cabeza la primera vez, pero ya el concepto esta bien aprendido.

Cerooo!!! 🥳

Amé esta clase

Hace poquito empecé a indagar el mundo de iOS, vengo de JavaScript, y mas contento no puedo estar. Estos cursos valen oro!

Usando el operador ternario para determinar cual funcion asignarle a la variable

import UIKit

func addTwoInts( _ a: Int,  _ b: Int ) -> Int {
     return a+b
}
func multiplyTwoInts( _ a: Int,  _ b: Int ) -> Int {
    return a*b
}

let isMember = false

var addinng: ( Int, Int ) -> Int = isMember ? addTwoInts : multiplyTwoInts;


addinng( 3, 7)```

Me parece que en el print debe ser con mathFunc para no confundir con la otra función:

func printMathResult(_ mathFunc: (Int, Int) -> Int, _ a: Int, _ b: Int){
    print("Resultado: \(mathFunc(a,b))")
}

printMathResult(multiplyTwoInts, 5, 9)

Primera clase que me toca ver a 1x excelente explicación

El resumen de la clase : 🤯

Basicamente al crear una variable de tipo funcion, por ejemplo mathFunction, lo unico que hace es crear un duplicado virtual de la funcion a la que esta igualando, con otro nombre.

otra forma es enumerar los parametros y crear algo así como una función lamda

func printMathResult(_ operation :(Int, Int) -> Int, _ a : Int , _ b : Int ){
    print("Result is : \(operation(a,b))")
}
printMathResult({$0 + $1}, 1, 2)

callbacks recargados… presiento el regreso de los callback hell de js…
Aunque se parece mas a los closures.

🤯

es como el tipado de TS, a un valor le dices que sera una funcion, mencionando que datos recibira y que datos retornara, incluso TS puedes ponerle el nombre o pasarle una funcion que seria un callback

Cuando el profesor dijo: “Ten cuidado, porque esto ya es nivel top y empieza a crecer en dificultad” me emocione porque ya empieza a verse lo bueno!
👨🏼‍💻🍕

Un pequeño ejercicio para entender un pco más

/*
 apuntes
 **/

func addThreeInts(_ a: Int, _ b: Int, c: Int) -> Int {
    return a+b+c
}

func printMathResultThreeValues(_ mathOperation: (Int, Int, Int) -> Int, _ a: Int, _ b: Int,_ c: Int){
    print("Result: \(mathOperation(a, b, c))")
}

printMathResultThreeValues(addThreeInts, 2, 4, 6)