Use-Ausdrücke in

Über Use-Ausdrücke

In Gleam ist es üblich, Funktionen höherer Ordnung zu schreiben und zu verwenden, also Funktionen, die andere Funktionen als Argumente entgegennehmen. Wenn man viele Funktionen höherer Ordnung auf einmal verwendet, kann der Code manchmal schwer zu lesen werden, weil er viele Ebenen der Einrückung hat.

Hier ist zum Beispiel eine Funktion, die mehrere Funktionen aufruft, die Result(Int, Nil) zurückgeben, und die Werte summiert, wenn alle vier erfolgreich sind.

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

Gleams use-Ausdrücke ermöglichen es uns, diesen Code ohne die Einrückung zu schreiben, was ihn oft leichter lesbar macht.

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

Ein use-Ausdruck sammelt alle folgenden Anweisungen im Block und übergibt sie als Callback-Funktion im letzten Argument an den Funktionsaufruf. Die Variablen zwischen dem use-Schlüsselwort und dem <--Symbol sind die Namen der Argumente, die an die Callback-Funktion übergeben werden.

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

Die Callback-Funktion kann beliebig viele Argumente entgegennehmen, oder auch gar keine.

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

use <- call_0_function()

Es gibt keine besonderen Voraussetzungen, um eine Funktion zu erstellen, die mit einem use-Ausdruck aufgerufen werden kann; sie muss nur eine Callback-Funktion als letztes Argument entgegennehmen.

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

Gleams use-Ausdrücke sind ein sehr mächtiges Feature, das sich auf viele Probleme anwenden lässt. Wenn man sie jedoch zu oft verwendet, kann der Code schwer zu lesen werden. Im Allgemeinen ist es besser, die normale Syntax für Funktionsaufrufe zu verwenden und nur dann zu use-Ausdrücken zu greifen, wenn sie den Code leichter lesbar machen.