Aller au contenu
Encyclopédie informatique Édition 2026

Elixir et la machine virtuelle d'Erlang

Partie 2 sur 3

Niveau de lecture :

4Les bases d’Elixir

4.1Des données qui ne changent pas

En Elixir, les valeurs sont immuables : une fois créée, une liste ne change plus. Ajouter un élément en produit une nouvelle liste (qui partage en mémoire l’essentiel de l’ancienne). Une variable peut être liée à une nouvelle valeur (x = 1 puis x = 2), mais cela ne modifie pas la valeur d’origine, que d’autres parties du programme conservent. C’est ce qui permet de faire travailler des milliers de processus sans conflit.

4.2Le filtrage par motifs

Le signe = n’est pas une simple affectation : c’est un filtrage par motifs (pattern matching). Le programme essaie de faire correspondre le motif à gauche avec la valeur à droite, et lie les variables au passage.

{:ok, valeur} = {:ok, 42}       # valeur vaut 42
[premier | reste] = [1, 2, 3]   # premier vaut 1, reste vaut [2, 3]

case File.read("notes.txt") do
  {:ok, contenu}   -> IO.puts(contenu)
  {:error, raison} -> IO.puts("échec : #{raison}")
end

Une fonction qui peut échouer renvoie par convention un couple {:ok, résultat} ou {:error, raison} (les mots précédés de deux-points, comme :ok, sont des atomes : des étiquettes constantes). Le case trie les possibilités, et si aucune ne correspond, une erreur est levée. On comprend le lien avec l’idée de traiter les erreurs comme des valeurs.

4.3Les types de données

Elixir manipule des nombres, des textes entre guillemets (stockés en UTF-8, voir les chaînes de caractères), des listes ([1, 2, 3]), des tuples (groupes de taille fixe, {:ok, 42}), des cartes (maps, associations clé-valeur, %{nom: "Awa"}) et des atomes. Il n’y a pas d’objets avec des méthodes : on appelle des fonctions sur des données.

4.4Fonctions et tube

Les fonctions sont regroupées dans des modules. Le code d’Elixir se lit souvent de gauche à droite grâce à l’opérateur tube (pipe, |>), qui passe le résultat d’une étape comme premier argument de la suivante :

"Bonjour le monde"
|> String.split(" ")
|> Enum.map(&String.upcase/1)
# donne ["BONJOUR", "LE", "MONDE"]

Au lieu d’imbriquer map(split(texte)), on enchaîne les étapes dans l’ordre. L’écriture &String.upcase/1 désigne la fonction upcase à un argument.

Il n’y a pas de boucle for à compteur ni de variables modifiées : on parcourt les listes par des fonctions comme Enum.map (transformer chaque élément), Enum.filter (garder certains éléments) ou Enum.reduce (combiner), et l’on utilise la récursion (une fonction qui s’appelle elle-même) pour les cas particuliers.

Pour s’exercer

Exercice 1 : Que vaut le filtrage ?

Pour chaque ligne d’Elixir, dites ce que valent les variables ou si une erreur est levée : (a) [a, b | reste] = [1, 2, 3, 4] ; (b) {:ok, x} = {:error, "disque plein"} ; (c) {_, y} = {"inutile", 7}.

Voir la réponse

(a) a vaut 1, b vaut 2 et reste vaut [3, 4] : le | récupère tout ce qui suit les deux premiers éléments. (b) Une erreur est levée (MatchError) : le motif attend :ok en premier élément et reçoit :error. (c) y vaut 7 ; le _ ignore la première valeur sans la garder.

Exercice 2 : Réécrire avec le tube

Réécrivez avec des tubes : Enum.sum(Enum.map(String.split("1 2 3"), &String.to_integer/1)). Que vaut le résultat ?

Voir la réponse
"1 2 3"
|> String.split()
|> Enum.map(&String.to_integer/1)
|> Enum.sum()

Chaque étape reçoit le résultat de la précédente comme premier argument. Le résultat est 6 (1 + 2 + 3).

5Superviser : « laisser planter »

5.1Une autre façon de penser la panne

Dans la plupart des langages, on essaie de prévoir chaque erreur avec des blocs try et catch (voir les exceptions). Erlang adopte la philosophie inverse, résumée par la formule « laisser planter » (let it crash) : écrire le code pour le cas normal, et quand quelque chose d’imprévu se produit, laisser le processus s’arrêter. Il n’emporte que sa propre mémoire, isolée. Quelqu’un d’autre se charge de la suite.

Ce « quelqu’un » est le superviseur : un processus dont le seul travail est de surveiller d’autres processus (ses « enfants ») et de les relancer selon une stratégie. Les superviseurs peuvent eux-mêmes être supervisés, ce qui forme un arbre de supervision (figure 2).

UN ARBRE DE SUPERVISION superviseur racine superviseur 1 superviseur 2 travail 1 travail 2 travail 3 travail 4 travail 5 travail 6 Si travail 2 tombe en panne, seul son superviseur direct intervient et le relance.
Figure 2. Un arbre de supervision : les pannes sont rattrapées au plus près.

5.2Les stratégies de redémarrage

Les trois stratégies de base :

  • un pour un (:one_for_one) : seul l’enfant en panne est relancé ;
  • un pour tous (:one_for_all) : tous les enfants sont relancés ensemble, quand ils dépendent les uns des autres ;
  • le reste (:rest_for_one) : l’enfant en panne et ceux démarrés après lui sont relancés.

Un superviseur limite aussi le nombre de relances dans un temps donné : si un enfant retombe sans cesse, le superviseur abandonne et s’arrête, et le problème remonte d’un étage. La panne n’est donc ni cachée ni infinie. Cette approche ne dispense pas d’écrire du code propre ; elle limite les dégâts d’une erreur et rend le système capable de se rétablir sans intervention.

Pour s’exercer

Exercice 3 : Qui est relancé ?

Un superviseur surveille trois processus A, B et C, démarrés dans cet ordre. B tombe en panne. Qui est relancé avec les stratégies :one_for_one, :one_for_all et :rest_for_one ?

Voir la réponse

Avec :one_for_one, seul B est relancé. Avec :one_for_all, A, B et C sont tous arrêtés puis relancés. Avec :rest_for_one, B est relancé ainsi que C (démarré après lui) ; A, démarré avant, n’est pas touché.