Expressions use en

À propos de Expressions use

En Gleam, il est courant d'écrire et d'utiliser des fonctions d'ordre supérieur, c'est-à-dire des fonctions qui prennent d'autres fonctions en arguments. Parfois, lorsqu'on utilise plusieurs fonctions d'ordre supérieur à la fois, le code peut devenir difficile à lire, avec de nombreuses couches d'indentation.

Par exemple, voici une fonction qui appelle plusieurs fonctions qui renvoient Result(Int, Nil), et qui additionne les valeurs si les quatre réussissent.

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

Les expressions use de Gleam permettent d'écrire ce code sans l'indentation, ce qui le rend souvent plus facile à lire.

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

Une expression use rassemble toutes les instructions qui suivent dans le bloc et les transmet, sous la forme d'une fonction de rappel, comme dernier argument de l'appel de fonction. Les variables situées entre le mot-clé use et le symbole <- sont les noms des arguments qui seront passés à la fonction de rappel.

// 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 fonction de rappel peut prendre n'importe quel nombre d'arguments, ou aucun.

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

use <- call_0_function()

Il n'y a aucune exigence particulière pour créer une fonction que l'on peut appeler avec une expression use, si ce n'est qu'elle doit prendre une fonction de rappel en dernier argument.

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

Les expressions use de Gleam sont une fonctionnalité très puissante qui peut s'appliquer à beaucoup de problèmes, mais quand on en abuse, elles peuvent rendre le code difficile à lire. Il est généralement préférable d'utiliser la syntaxe d'appel de fonction normale et de ne recourir aux expressions use que lorsqu'elles rendent le code plus facile à lire.