Expresiones use en

Acerca de Expresiones use

En Gleam es común escribir y usar funciones de orden superior, es decir, funciones que reciben otras funciones como argumentos. A veces, cuando usas 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í hay 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 sentencias que siguen en el bloque y las pasa como una función de callback como argumento final a la llamada a la función. Las variables 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 cantidad de argumentos, o ninguno.

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

use <- call_0_function()

No hay requisitos especiales para crear una función que se pueda llamar con una expresión use, más allá de recibir 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 funciones y recurrir a las expresiones use solo cuando hacen que el código sea más fácil de leer.