Elixir et la machine virtuelle d'Erlang
Partie 2 sur 3
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).
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é.