Parcours sur parcours sur parcours

Listes

Un tableau en Gleam est une collection immuable de zéro ou plusieurs valeurs. Toutes les valeurs d'un tableau doivent avoir le même type. Comme les tableaux sont immuables, une fois qu'un tableau est construit, sa valeur ne peut plus jamais changer. Toutes les fonctions et tous les opérateurs qui semblent modifier un tableau (comme l'ajout d'un élément) renvoient en réalité un nouveau tableau.

On peut définir un tableau comme ceci :

let empty = []
let singleValue = [5]
let threeValues = ["a", "b", "c"]

La façon la plus courante d'ajouter un élément à un tableau est d'utiliser la syntaxe de propagation :

let two_to_four = [2, 3, 4]
let one_to_four = [1, ..two_to_four]
// -> [1, 2, 3, 4]

Le module gleam/list de la bibliothèque standard de Gleam contient de nombreuses fonctions utiles pour travailler avec les tableaux. Ce module est très couramment utilisé dans le code Gleam, il est donc bon de le connaître.

Les motifs de tableau peuvent être utilisés dans les expressions case pour faire correspondre des tableaux et affecter les valeurs qu'ils contiennent à des variables :

pub fn describe(list: List(String)) -> String {
  case list {
    [] -> "Empty list"
    [x] -> "List with one item: " <> x
    [x, y] -> "List with two items: " <> x <> " and " <> y
    _ -> "List with three or more items"
  }
}

Outre la correspondance sur des tableaux de longueur exacte, la syntaxe de propagation permet de faire correspondre des tableaux d'au moins une certaine longueur :

pub fn describe(list: List(String)) -> String {
  case list {
    [_, _, ..] -> "List with at least two items"
    [_] -> "List with one item"
    [] -> "Empty list"
  }
}

La syntaxe de propagation permet aussi d'affecter le reste du tableau à une variable :

pub fn remove_first_item(list: List(String)) -> List(String) {
  case list {
    // Return the list without the first item
    [_, ..rest] -> rest

    // There's no first item to remove, return an empty list
    _ -> []
  }
}

Les expressions case doivent avoir un motif pour chaque valeur possible du type sur lequel porte la correspondance ; on utilise donc souvent un motif à ignorer (_) à la fin pour gérer les valeurs restantes.