Introdução
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 várias funções de ordem superior ao mesmo tempo, 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 tiverem sucesso.
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 escrever esse código sem a indentação, o que muitas vezes o deixa 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 coleta todas as instruções seguintes do bloco e as passa como uma função de callback, no 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 do 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, prefere-se usar a sintaxe normal de chamada de função e recorrer às expressões use apenas quando elas deixarem o código mais fácil de ler.
Instruções
Daphne vem trabalhando em um sistema para rodar e registrar os resultados de seus experimentos. Parte do código ficou um pouco verbosa e repetitiva, então ela pediu que você escrevesse algumas expressões use para ajudar a limpá-lo.
1. Defina a função with_retry
Às vezes um experimento pode falhar por causa de um erro isolado, então, se um experimento falhar, Daphne quer tentar de novo para ver se funciona na segunda vez.
Defina a função with_retry, que recebe como argumento uma função que retorna um resultado.
Se a função retornar um valor Ok, with_retry deve retornar esse valor.
Se a função retornar um valor Error, with_retry deve chamar a função de novo e retornar o resultado dessa chamada.
Daphne vai usar a função assim:
pub fn main() {
use <- with_retry
// Perform the experiment here
}
2. Defina a função record_timing
Daphne registra quanto tempo cada experimento leva para rodar, chamando uma função de registro de tempo antes e depois de cada experimento.
Defina a função record_timing, que recebe dois argumentos:
- Uma função de registro de tempo, que não recebe argumentos e retorna
Nil.
- Uma função de experimento, que não recebe argumentos e retorna um resultado.
record_timing deve chamar a função de registro de tempo, depois chamar a função de experimento, depois chamar a função de registro de tempo de novo e, por fim, retornar o resultado da função de experimento.
Daphne vai usar a função assim:
pub fn main() {
use <- record_timing(time_logger)
// Perform the experiment here
}
3. Defina a função run_experiment
Um experimento é composto de três fases: a preparação, a ação e o registro. As três fases retornam resultados, e cada fase precisa do resultado bem-sucedido da fase anterior para rodar.
Defina a função run_experiment, que recebe quatro argumentos:
- O nome do experimento como uma
String.
- Uma função de preparação, que não recebe argumentos e retorna um resultado.
- Uma função de ação, que recebe como argumento o valor
Ok da função de preparação e retorna um resultado.
- Uma função de registro, que recebe como argumentos o valor
Ok das funções de preparação e de ação e retorna um resultado.
Se as três funções tiverem sucesso, run_experiment deve retornar Ok(#(experiment_name, recording_data)).
Se alguma das funções retornar um valor Error, run_experiment deve retornar esse valor.
Daphne vai usar a função assim:
pub fn main() {
use setup_data, action_data <- run_experiment("Test 1", setup, action)
// Record the results here
}
Exercício de aprendizagem
