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. Por vezes, quando usamos muitas funções de ordem superior ao mesmo tempo, o código pode tornar-se difícil de ler, com muitos níveis de indentação.

Por exemplo, aqui está uma função que chama várias funções que devolvem Result(Int, Nil) e soma os valores se 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 do Gleam permitem-nos escrever este código sem a indentação, o que muitas vezes o torna mais fácil de ler.

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 passa-as à função chamada como último argumento, na forma de uma função de callback. As variáveis entre a palavra-chave use e o símbolo <- são os nomes dos argumentos que serão passados à 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á requisitos especiais para criar uma função que possa ser chamada com uma expressão use, para 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 do Gleam são uma funcionalidade muito poderosa que pode ser aplicada a muitos problemas, mas, quando usadas em excesso, podem tornar 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 apenas quando tornam o código mais fácil de ler.