DEV Community: Lautaro Strappazzon

Funciones Anónimas en Golang [#Go101]

Lautaro Strappazzon — Wed, 21 Feb 2024 23:05:46 +0000

Introducción

Las funciones anónimas (funciones lambda o funciones literales) son aquellas que no están vinculadas a un identificador. En Golang son principalmente usadas para diferir tareas o ejecutarlas concurrentemente; para pasar funciones como argumentos, entre otros casos de uso que vamos a cubrir hoy.

Casos de uso

Funciones como argumentos

Cuando una función de orden superior tiene como parámetro otra función, es usual ver que funciones anónimas son pasadas como parámetros a estas. A esto también se le llama “callbacks”.

func forEach(numbers []int, f func(int)) {
  for _, num := range numbers {
    f(num)
  }
}

func main() {
    forEach([]int{1, 2, 3}, func(i int) {
      fmt.Printf("%d ", i * i) // Output: 1 4 9
    })
}

Ejecuta el código:

go.dev

Ejecuciones concurrentes (Goroutines)

Otro uso común es a la hora de lanzar Goroutines, sobre todo cuando la función es simple y sólo se utiliza en ese lugar. Esto nos permite mantener la lógica cerca de donde es utilizada, mejorando la legibilidad.

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        // Código que se ejecuta concurrentemente
        fmt.Println("Ejecutando en una goroutine")
        wg.Done()
    }()
    wg.Wait()

    fmt.Println("Ejecutando en la función main")
}

Ejecuta el código:

go.dev

ADVERTENCIA: Funciones anónimas muy largas pueden generar el efecto contrario en la legibilidad, haciendo difícil entender el código.

Diferir tareas

Cuando queremos diferir la ejecución de más de una función en general utilizamos funciones anónimas.

func main() {
    now := time.Now()
    defer func() {
        duration := time.Since(now)
        fmt.Printf("Se tardó %v en ejecutar esto", duration)
    }()

    for i := range 1_001 {
        if i%100 == 0 {
            fmt.Printf("%d ", i)
            time.Sleep(time.Millisecond * 100)
        }
    }
    fmt.Printf("\n")
} 
// Output:
// 0 100 200 300 400 500 600 700 800 900 1000
// Se tardó 1.1s en correr esto

Ejecuta el código:

go.dev

Clausuras o closures

Las funciones anónimas pueden capturar variables dentro de su scope y mantener acceso a ellas aún cuando la función exterior o padre ya ha retornado. Esto nos permite crear funciones que “recuerdan” estado.

func makeMultiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

func main() {
    multiplyByTwo := makeMultiplier(2)
    r1 := multiplyByTwo(2)
    fmt.Println(r1) // Output: 4
    r2 := multiplyByTwo(5)
    fmt.Println(r2) // Output: 10
}

Ejecuta el código:

go.dev

ADVERTENCIA: A pesar de su potencial, hay que saber cuándo y cómo utilizar closures porque pueden traer problemas de uso de memoria, de legibilidad; bugs a la hora de manejar ese “estado”, sobre todo concurrentemente; o dificultades a la hora de debuggear.

Testing

Solemos usar funciones anónimas para correr “sub tests” en Table-Driven Tests:

func Add(a, b int) int {
    return a + b
}

func TestAdd(t *testing.T) {
    testCases := []struct {
        a, b, expected int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }

    for _, tc := range testCases {
        t.Run(fmt.Sprintf("%d+%d", tc.a, tc.b), func(t *testing.T) {
            result := Add(tc.a, tc.b)
            if result != tc.expected {
                t.Errorf("Expected %d, got %d", tc.expected, result)
            }
        })
    }
}

Volviendo a las clausuras o closures, el siguiente es un patrón que le robé a Mat Ryer en una de sus charlas en GopherCon UK que recomiendo enormemente.

func TestSomething(t *testing.T) {
    file, teardown, err := setup(t)
    defer teardown()
    if err != nil {
        t.Error("setup:", err)
    }
    // hacer algo con el archivo
}

func setup(t *testing.T) (*os.File, func(), error) {
    teardown := func() {}
    // crear archivo de test
    file, err := os.CreateTemp(os.TempDir(), "test")
    if err != nil {
        return nil, teardown, err
    }

    teardown = func() {
        // cerrar archivo
        err := file.Close()
        if err != nil {
            t.Error("setup: Close:", err)
        }
        // borrar archivo de prueba
        err = os.RemoveAll(file.Name())
        if err != nil {
            t.Error("setup: RemoveAll:", err)
        }
    }
    return file, teardown, nil
}

Pros y contras

Pros:

Concisión: Permiten definir y usar funciones directamente donde las necesitas, lo que reduce el desorden en tu código y el tamaño de tus APIs internas o privadas.
Legibilidad (para tareas simples): las funciones anónimas pueden hacer el código más fácil de leer manteniéndolo cerca de donde se utiliza.

Contras:

Testabilidad y debugging: al no estar explicitamente definidas y nombradas, pueden ser más difíciles de testear y debuggear.
Legibilidad (para tareas largas o complejas): cuando esto sucede, el código puede ser más difícil de comprender.

Conclusiones

Las funciones anónimas pueden ser una herramienta muy poderosa, pero hay que elegir cuidadosamente cuando las utilizamos. En resumen, puedes utilizarlas cuando su lógica es simple y corta, y no va a ser reutilizada; y/o cuando necesites hacer uso de closures.

En los casos en los que su lógica se vuelve muy compleja o la función va a ser reutilizada en otros lugares, considera definirla como una función nombrada para mayor mantenibilidad y claridad.

Golang Anonymous Functions: A Guide [#Go101]

Lautaro Strappazzon — Wed, 21 Feb 2024 22:42:51 +0000

Introduction

Anonymous functions (lambda functions or literal functions) are those that are not bound to an identifier. In Golang, they are primarily used to defer tasks or execute them concurrently; to pass functions as arguments, among other use cases that we will cover today.

Use Cases

Functions as Arguments

When a higher-order function takes another function as a parameter, it is common to see anonymous functions passed as parameters to these. This is also called "callbacks."

func forEach(numbers []int, f func(int)) {
  for _, num := range numbers {
    f(num)
  }
}

func main() {
    forEach([]int{1, 2, 3}, func(i int) {
        fmt.Printf("%d ", i * i) // Output: 1 4 9
    })
}

Run this code:

go.dev

Concurrent Executions (Goroutines)

Another common use is when launching Goroutines, especially when the function is simple and only used in that place. This allows us to keep the logic close to where it is used, improving readability.

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        // Code running concurrently
        fmt.Println("Running in a goroutine")
        wg.Done()
    }()
    wg.Wait()

    fmt.Println("Running in the main function")
}

Run this code:

go.dev

WARNING: Very long anonymous functions may have the opposite effect on readability, making it challenging to understand the code.

Deferring Tasks

When we want to defer the execution of more than one function, we generally use anonymous functions.

func main() {
    now := time.Now()
    defer func() {
        duration := time.Since(now)
        fmt.Printf("It took %v to run this", duration)
    }()

    for i := range 1_001 {
        if i%100 == 0 {
            fmt.Printf("%d ", i)
            time.Sleep(time.Millisecond * 100)
        }
    }
    fmt.Printf("\n")
}
// Output:
// 0 100 200 300 400 500 600 700 800 900 1000
// It took 1.1s to run this

Run this code:

go.dev

Closures

Anonymous functions can capture variables within their scope and maintain access to them even when the outer or parent function has already returned. This allows us to create functions that "remember" state.

func makeMultiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

func main() {
    multiplyByTwo := makeMultiplier(2)
    r1 := multiplyByTwo(2)
    fmt.Println(r1) // Output: 4
    r2 := multiplyByTwo(5)
    fmt.Println(r2) // Output: 10
}

Run this code:

go.dev

WARNING: Despite their potential, one must know when and how to use closures because they can bring issues of memory usage, readability, bugs when handling that "state," especially concurrently, or difficulties in debugging.

Testing

We often use anonymous functions to run "subtests" in Table-Driven Tests:

func Add(a, b int) int {
    return a + b
}

func TestAdd(t *testing.T) {
    testCases := []struct {
        a, b, expected int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }

    for _, tc := range testCases {
        t.Run(fmt.Sprintf("%d+%d", tc.a, tc.b), func(t *testing.T) {
            result := Add(tc.a, tc.b)
            if result != tc.expected {
                t.Errorf("Expected %d, got %d", tc.expected, result)
            }
        })
    }
}

Returning to closures, the following is a pattern I borrowed from Mat Ryer in one of his talks at GopherCon UK that I highly recommend.

func TestSomething(t *testing.T) {
    file, teardown, err := setup(t)
    defer teardown()
    if err != nil {
        t.Error("setup:", err)
    }
    // do something with the file
}

func setup(t *testing.T) (*os.File, func(), error) {
    teardown := func() {}
    // create test file
    file, err := os.CreateTemp(os.TempDir(), "test")
    if err != nil {
        return nil, teardown, err
    }

    teardown = func() {
        // close file
        err := file.Close()
        if err != nil {
            t.Error("setup: Close:", err)
        }
        // remove test file
        err = os.RemoveAll(file.Name())
        if err != nil {
            t.Error("setup: RemoveAll:", err)
        }
    }
    return file, teardown, nil
}

Pros and Cons

Pros:

Conciseness: Allows you to define and use functions directly where you need them, reducing clutter in your code and the size of your internal or private APIs.
Readability (for simple tasks): Anonymous functions can make the code easier to read by keeping it close to where it is used.

Cons:

Testability and debugging: As they are not explicitly defined and named, they can be more challenging to test and debug.
Readability (for long or complex tasks): When this happens, the code can become harder to understand.

Conclusions

Anonymous functions can be a powerful tool, but one must choose carefully when to use them. In summary, you can use them when their logic is simple and short, and it will not be reused; and/or when you need to make use of closures.

In cases where their logic becomes very complex or the function will be reused elsewhere, consider defining it as a named function for greater maintainability and clarity.