Expressões use em

Sobre Expressões use

Em Gleam é comum escrever e usar funções de ordem superior, ou seja, funções que recebem outras funções como argumentos. Às vezes, ao usar muitas funções de ordem superior de uma só vez, o código pode ficar difícil de ler, com muitas camadas de indentação.

Por exemplo, aqui está uma função que chama várias funções que retornam Result(Int, Nil) e soma os valores se todas as quatro forem bem-sucedidas.

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)
        })
      })
    })
  })
}

As expressões use de Gleam permitem escrever esse código sem a indentação, o que muitas vezes deixa a leitura mais fácil.

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)
}

Uma expressão use recolhe todas as instruções seguintes do bloco e as passa como uma função de callback, na condição de argumento final da chamada de função. As variáveis entre a palavra-chave use e o símbolo <- são os nomes dos argumentos que serão passados para a função 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
})

A função de callback pode receber qualquer número de argumentos, ou nenhum.

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

use <- call_0_function()

Não há nenhum requisito especial para criar uma função que possa ser chamada com uma expressão use, além de receber uma função de callback como argumento final.

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

As expressões use de Gleam são um recurso muito poderoso, que pode ser aplicado a muitos problemas, mas, quando usadas em excesso, podem deixar o código difícil de ler. Em geral, é preferível usar a sintaxe normal de chamada de função e recorrer às expressões use só quando elas deixarem o código mais fácil de ler.