Expresiones use en

Acerca de Expresiones use

En Gleam es habitual escribir y usar funciones de orden superior, es decir, funciones que toman otras funciones como argumentos. A veces, cuando se usan muchas funciones de orden superior a la vez, el código puede volverse difícil de leer, con muchas capas de indentación.

Por ejemplo, aquí tienes una función que llama a varias funciones que devuelven Result(Int, Nil) y suma los valores si las cuatro tienen éxito.

import gleam/result

pub fn main() -> Result(Int, Nil) {
  result.try(function1(), fn(a) {
    result.try(function2(), fn(b) {
      result.try(function3(), fn(c) {
        result.try(function4(), fn(d) {
          Ok(a + b + c + d)
        })
      })
    })
  })
}

Las expresiones use de Gleam nos permiten escribir este código sin la indentación, lo que a menudo lo hace más fácil de leer.

import gleam/result

pub fn main() -> Result(Int, Nil) {
  use a <- result.try(function1())
  use b <- result.try(function2())
  use c <- result.try(function3())
  use d <- result.try(function4())
  Ok(a + b + c + d)
}

Una expresión use recoge todas las instrucciones que siguen en el bloque y las pasa como función de callback como argumento final de la llamada a la función. Las variables que hay entre la palabra clave use y el símbolo <- son los nombres de los argumentos que se pasarán a la función de callback.

// This use expression
use a <- function(1, 2)
io.println("Hello!")
a

// Is equivalent to this normal function call
function(1, 2, fn(a) {
  io.println("Hello!")
  a
})

La función de callback puede recibir cualquier número de argumentos, o ninguno.

use a, b, c, d <- call_4_function()

use <- call_0_function()

No hay ningún requisito especial para crear una función que se pueda llamar con una expresión use, más allá de que tome una función de callback como argumento final.

pub fn call_twice(function: fn() -> t) -> #(t, t) {
  let first = function()
  let second = function()
  #(first, second)
}

Las expresiones use de Gleam son una funcionalidad muy potente que se puede aplicar a muchos problemas, pero cuando se abusa de ellas pueden hacer que el código sea difícil de leer. Por lo general, se prefiere usar la sintaxis normal de llamada a función y recurrir a las expresiones use solo cuando hagan que el código sea más fácil de leer.