Espressioni use in

Informazioni su Espressioni use

In Gleam è comune scrivere e usare funzioni di ordine superiore, cioè funzioni che accettano altre funzioni come argomenti. A volte, quando si usano molte funzioni di ordine superiore nello stesso momento, il codice può diventare difficile da leggere, con molti livelli di indentazione.

Per esempio, ecco una funzione che chiama diverse funzioni che restituiscono Result(Int, Nil) e somma i valori se tutte e quattro hanno successo.

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

Le espressioni use di Gleam ci permettono di scrivere questo codice senza l'indentazione, rendendolo spesso più facile da leggere.

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

Un'espressione use raccoglie tutte le istruzioni che seguono nel blocco e le passa alla chiamata di funzione come ultimo argomento, sotto forma di funzione di callback. Le variabili tra la parola chiave use e il simbolo <- sono i nomi degli argomenti che verranno passati alla funzione di 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 funzione di callback può accettare un numero qualsiasi di argomenti, o nessuno.

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

use <- call_0_function()

Non ci sono requisiti speciali per creare una funzione che possa essere chiamata con un'espressione use, se non quello di accettare una funzione di callback come ultimo argomento.

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

Le espressioni use di Gleam sono una funzionalità molto potente che si può applicare a molti problemi, ma se usate troppo rendono il codice difficile da leggere. In genere è preferibile usare la normale sintassi di chiamata di funzione e ricorrere alle espressioni use solo quando rendono il codice più facile da leggere.