Découverte du langage Elixir

Posté par  (site web personnel) . Édité par bobble bubble et Xavier Teyssier. Modéré par Xavier Teyssier. Licence CC By‑SA.
38
2
nov.
2026
Programmation fonctionnelle

Beaucoup de Rust par-ci… Un peu de Go par-là… Saupoudrez de LLM selon vos goûts et vous aurez une bonne photographie des sujets qui préoccupent les développeurs sur l'Internet d'aujourd'hui.
Alors, n'est-ce pas le meilleur moment pour se rafraîchir l'esprit avec des langages plus discrets ?
Je vous propose ici une présentation accélérée d'Elixir.

Sommaire

Un langage de programmation fonctionnelle

Ceux qui ont déjà fait de la programmation orientée objet organisent principalement leur code autour d'objets et d'instances. Cette approche a ses avantages, mais cela nécessite d'encapsuler la donnée et la gestion des changements d'état peut parfois devenir complexe.
De son côté, la programmation fonctionnelle privilégie les fonctions qui, au lieu de masquer les données, transforment simplement des entrées en sorties.
Elixir s'appuie essentiellement sur ce paradigme.

Correspondance de motifs (ou Pattern matching)

En Elixir, le signe égal n'est pas une affectation mais plutôt une assertion.
Ainsi, on n'affecte ou ne modifie la valeur que de la variable située à gauche du signe égal. À droite, la variable est remplacée par sa valeur. Exemple avec iex, la console interactive :

iex> a = 2
2
iex> 2 = a
2
iex> 1 = a
** (MatchError) no match of right hand side value: 2

Cette ligne de code échoue car elle équivaut à 1 = 2, ce qui provoque une erreur.
À noter que le caractère _ sert à ignorer une valeur, ainsi :

iex> [1, _, _] = [1, 2, 3]
[1, 2, 3]

La correspondance de motifs en Elixir est similaire à celle d'Erlang (ces deux langages utilisent la même VM).
Joe Armstrong, le créateur d'Erlang, compare ce signe égal à celui utilisé en algèbre : lorsque vous écrivez l'équation x = a + 1, vous n'attribuez pas la valeur de a + 1 à x.
Cette correspondance sert essentiellement à vérifier la forme d'une valeur, à en extraire des éléments et à traiter différemment les résultats d'une opération selon qu'elle réussit ou échoue.
Tout cela est un peu déroutant au début mais très puissant.

Module, fonctions et clauses de garde

Dès qu'un programme dépasse quelques lignes, il devient nécessaire de le structurer.
En Elixir, les fonctions nommées doivent être écrites à l'intérieur de modules :

defmodule BestMovie do
  def ever(name) do
    IO.puts "Le meilleur film de tous les temps est `#{name}`."
  end
end
BestMovie.ever("La cité de la peur") #=> Le meilleur film de tous les temps est `La cité de la peur`.

De son côté, la macro defp définit une fonction privée, c'est-à-dire une fonction qui ne peut être appelée qu'au sein du module qui la déclare :

defmodule MonModule do
  def fonction_publique do
    fonction_privée()
  end

  defp fonction_privée do
    IO.puts "Je suis appelé depuis une fonction privée"
  end
end
MonModule.fonction_privée()   #=> ** (UndefinedFunctionError) function MonModule.fonction_privée/0 is undefined or private.
MonModule.fonction_publique() #=> Je suis appelé depuis une fonction privée

En Elixir, la correspondance de motifs s'applique aux arguments des fonctions : plusieurs peuvent porter le même nom mais le langage choisira la fonction dont les motifs correspondent aux arguments.
Au moyen du mot clé when, les clauses de garde permettent d'étendre cette correspondance de motifs à des vérifications plus complexes comme la distinction des types d'arguments ou un test portant sur leurs valeurs :

defmodule GuardClause do
  def what_is(x) when is_number(x) and x > 0 do
    IO.puts "#{x} est un nombre positif"
  end

  def what_is(x) when is_list(x) do
    IO.puts "#{inspect(x)} est une liste"
  end
end
GuardClause.what_is(99)      #=> 99 est un nombre positif
GuardClause.what_is([1,2,3]) #=> [1,2,3] est une liste

Toutes les expressions ne sont pas autorisées dans les clauses de garde, mais seulement quelques-unes.
Il s'agit d'un choix délibéré du langage pour garantir une exécution efficace.

Listes et récursivité

En Elixir, une liste peut être vide ou se composer d'une tête et d'une queue. La tête (head) contient une valeur et la queue (tail) est elle-même une liste :

iex> [ head | tail ] = [ 1, 2, 3 ]
[1, 2, 3]
iex> head
1
iex> tail
[2, 3]

Ainsi, une liste à un seul élément (que nous écririons habituellement sous la forme [4]) peut s'écrire comme la valeur 4 jointe à une liste vide, soit [ 4 | [ ] ].
Cette définition permet d'aborder certains problèmes de manière récursifs et donc sans s'appuyer sur une variable de boucle et/ou les traditionnels if et else :

defmodule MyList do
  def flip([]), do: []
  def flip([ head | tail ]) do
    flip(tail) ++ [head] # `++` permet de concaténer des listes
  end
end
MyList.flip([1, 2, 3, 4, 5]) #=> [5, 4, 3, 2, 1]
# Explication pas à pas :
#   flip([1, 2, 3, 4, 5])
#     ↳ flip([2, 3, 4, 5]) ++ [1]
#         ↳ flip([3, 4, 5]) ++ [2] ++ [1]
#             ↳ flip([4, 5]) ++ [3] ++ [2] ++ [1]
#                 ↳ flip([5]) ++ [4] ++ [3] ++ [2] ++ [1]
#                     ↳ flip([]) ++ [5] ++ [4] ++ [3] ++ [2] ++ [1]
#                         ↳ [] ++ [5] ++ [4] ++ [3] ++ [2] ++ [1]
#                             ↳ [5, 4, 3, 2, 1]

Note : l'usage de ++ est moins efficace qu'une version utilisant une variable pour accumuler le résultat mais cette approche reste plus didactique pour découvrir la récursion.

L'opérateur pipe

Nous avons tous déjà croisé du code séquentiel où chaque étape dépend du résultat de la précédente :

  cart = ShoppingCart.for_user(user_id)
  items = Inventory.check_availability(cart)
  total = Pricing.calculate_total(items, tax: 1.2)

L'ordre des opérations est clair, mais au final les variables intermédiaires sont là pour éviter des appels imbriqués :

Pricing.calculate_total(
  Inventory.check_availability(
    ShoppingCart.for_user(user_id)
  ),
  tax: 1.2
)

Elixir propose d'écrire ce type de code d'une façon fluide et sans variable intermédiaire :

user_id
|> ShoppingCart.for_user()
|> Inventory.check_availability()
|> Pricing.calculate_total(tax: 1.2)

L'opérateur |> prend le résultat de l'expression située précédemment et l'insère en tant que premier paramètre de l'appel de la fonction suivante.

L'exercice sympa qui utilise tout ça (ou presque)

Maintenant que vous avez les bases, je vous propose un exercice qui m'avait bien plu lorsque j'ai découvert le langage au travers le livre de Dave Thomas : trouver un nombre compris dans un intervalle donné (ex : 1..100 dans une expression ou 1..100//1 pour effectuer une correspondance de motifs, //1 correspondant au pas).
Il existe plusieurs façon de résoudre le problème mais voici ma solution :

defmodule Devine do
  def en_tatonnant(cible, min..max//1) when is_integer(cible) and is_integer(min) and is_integer(max) and cible > min and cible < max do
    estimation = div(min + max, 2)
    IO.puts "Est-ce #{estimation} ?"
    guess(cible, min..max, estimation)
  end
  def en_tatonnant(cible, min..max//1) when not is_integer(cible) or not is_integer(min) or not is_integer(max) or cible < min or cible > max do
    IO.puts "Très drôle…"
  end
  defp guess(cible, min.._//1, estimation) when estimation > cible do
    IO.puts "Non, c'est plus petit… Maintenant on va rechercher entre #{min} et #{estimation}"
    en_tatonnant(cible, min..estimation)
  end
  defp guess(cible, _..max//1, estimation) when estimation < cible do
    IO.puts "Non, c'est plus grand… Maintenant on va rechercher entre #{estimation} et #{max}"
    en_tatonnant(cible, estimation..max)
  end
  defp guess(cible, _, estimation) when estimation == cible do
    IO.puts "Mais oui, c'est bien #{estimation} 🤩"
  end
end
Devine.en_tatonnant(273, 1..1000)
#=> Est-ce 500 ?
#=> Non, c'est plus petit… Maintenant on va rechercher entre 1 et 500
#=> Est-ce 250 ?
#=> Non, c'est plus grand… Maintenant on va rechercher entre 250 et 500
#=> Est-ce 375 ?
#=> Non, c'est plus petit… Maintenant on va rechercher entre 250 et 375
#=> Est-ce 312 ?
#=> Non, c'est plus petit… Maintenant on va rechercher entre 250 et 312
#=> Est-ce 281 ?
#=> Non, c'est plus petit… Maintenant on va rechercher entre 250 et 281
#=> Est-ce 265 ?
#=> Non, c'est plus grand… Maintenant on va rechercher entre 265 et 281
#=> Est-ce 273 ?
#=> Mais oui, c'est bien 273 🤩

Et maintenant

Vous vous doutez bien que je n'ai fait qu'effleurer le sujet mais j'ai trouvé le langage Elixir tellement singulier que je n'ai pas résisté à l'envie de vous le présenter.
Je continue ma découverte de ce langage, à mon rythme ; en ce moment, j'aborde la programmation concurrente.
À n'en pas douter, j'enchaînerai sur le framework Phoenix !

Aller plus loin

  • # Syntaxe similaire à Ruby

    Posté par  . Évalué à 3 (+2/-0). Dernière modification le 02 novembre 2026 à 11:51.

    La syntaxe des exemples de code dans l'article me faisant beaucoup penser à Ruby (déclaration des fonctions, opérateurs pipe, …) et Dave Thomas mentionné dans l'article ayant aussi écrit plusieurs livres sur Ruby, je me suis dit qu'il devait avoir un lien entre ces 2 langages.

    Et en effet, dans la page Wikipedia d'Elixir:

    Il est créé en 2011 par le développeur José Valim, personnalité du monde Ruby et l'un des premiers contributeurs au framework de programmation Ruby on Rails.

    💡

    C'est le 2ème langage que je rencontre s'étant inspiré de la syntaxe Ruby. L'autre étant Crystal

    • [^] # Re: Syntaxe similaire à Ruby

      Posté par  (site web personnel, Mastodon) . Évalué à 4 (+3/-1).

      Une des idées à l'origine d'Elixir est en effet de faire du Erlang (pour profiter de son parallélisme et de sa machine virtuelle) mais avec une syntaxe proche de Ruby (celle d'Erlang est horrible).

      • [^] # Re: Syntaxe similaire à Ruby

        Posté par  (site web personnel) . Évalué à 8 (+6/-0). Dernière modification le 03 novembre 2026 à 01:14.

        La syntaxe d'erlang n'est pas horrible, au contraire. Elle est extrêmement simple. En moins d'1h tu sais tout ce qu'il y a à savoir sur la syntaxe.

        Tu veux une syntaxe horrible ? Regarde C++ ou Rust. Extrêmement complexe, même avec des années de pratique, tu ne peux pas tout avoir en tête.

        https://link-society.com - https://flowg.cloud - https://krouter.cloud

  • # Parallélisme

    Posté par  (site web personnel, Mastodon) . Évalué à 10 (+8/-0). Dernière modification le 02 novembre 2026 à 14:01.

    En effet, cela vaut la peine de parler de programmation parallèle car c'est une des grandes forces d'Elixir.

    Des exemples de programmes réels écrits en Elixir : Pleroma, Mobilizon, CertStream…

    Et on peut aussi faire du DNS (là, le parallélisme est crucial, sans lui, Elixir a nettement moins d'intérêt).

  • # Les langages...

    Posté par  . Évalué à 3 (+1/-1).

    C'est marrant, il y a toujours des débats passionnés sur les langages, ceux qui sont mieux, ceux qui sont moches, etc. Au final, je ne suis pas si sûr que le langage lui-même compte tant que ça, par rapport aux considérations d'environnement (dépendances disponibles, possibilité de former/de recruter des spécialistes, etc).

    Sur le sujet des pipes, autant je trouve ça très pertinent quand il s'agit d'éviter les variables intermédiaires de même type (du style data |> filtre1() |> filtre2() ) pour des séries de traitements pour lesquelles on peut décider de sauter ou d'inverser des étapes, autant les changements de types comme suggéré ici, je trouve que ça frôle les mauvaises pratiques, parce que la lisibilité est assez dégueu. Il suffit d'un peu de templates pour qu'on se retrouve embarqués dans des séries de cast auto dans un labyrinthe inextricable…

    • [^] # Re: Les langages...

      Posté par  (site web personnel) . Évalué à 7 (+5/-0).

      Au final, je ne suis pas si sûr que le langage lui-même compte tant que ça

      Alors là, pas d'accord du tout. Malheureusement, le monde est très ancré dans les langages procéduraux, et les plus connus se ressemblent effectivement pas mal. Donc effectivement, si tu compares python, c, c++, java, etc… tu trouves peut être que ça se ressemble (et encore). Mais la diversité des approches est bien plus grande que ça.

      Et les propriétés d'un langage influencent la façon dont son écosystème est construit, la culture de ses utilisateurs, etc … (qui eux même viennent influencer la façon dont évolue le langage). Donc on ne peut pas vraiment séparer tout ça en pratique.

      • [^] # Re: Les langages...

        Posté par  (site web personnel, Mastodon) . Évalué à 5 (+3/-0).

        Oui, si quelqu'un prétend que tous les langages sont équivalents, je vais lui demander de recoder un programme Lisp en Rust… (Ou un programme en langage d'assemblage vers Prolog, si je suis de mauvaise humeur.) Par exemple, si on écrit un programme qui doit traiter beaucoup de requêtes réseau (un serveur DNS faisant autorité, par exemple), on ne gérera pas du tout pareil en C (où on fera sans doute par événements, par exemple avec libevent) et en Elixir (où on utilisera les processus de la VM Erlang - qui n'ont rien à voir avec les processus du système d'exploitation). Les deux programmes seront alors radicalement différents. (Et je ne parle pas de la gestion des erreurs, qui est là aussi sans comparaison possible entre C et Elixir.)

        • [^] # Re: Les langages...

          Posté par  . Évalué à -2 (+0/-5).

          Je vais lui demander de recoder un programme Lisp en Rust…

          Est-ce qu'un LLM ne ferait pas ça de manière convaincante en moins de temps qu'il ne faut pour le dire?

          Est-ce qu'il ne s'agit pas non plus d'un débat théorique, puisqu'en pratique il y a très peu de développement en dehors des langages populaires, et que > 90% du marché tourne autour de paradigmes proches? (C, C++, Python, java, C#, etc)?

          Demander de recoder du Rust en Lisp, c'est comme traduire de l'Ukrainien en Vietnamien (je n'ai pas pris les exemples au hasard, c'est basé sur les % de locuteurs), et te plaindre que c'est difficile de trouver quelqu'un qui pratique les deux.

          En pratique, je pense que parmi les centaines de logiciels installés sur mes bécanes, aucun n'est codé en Erlang, Prolog, Lisp (j'ai pas emacs, je viens de vérifier) ou en Elixir. Ce sont des langages de recherche, qui ont un intérêt théorique, mais personne ou presque ne code de logiciel utile avec ça, tu ne peux pas prétendre qu'ils sont des alternatives crédibles aux langages populaires.

  • # présentation

    Posté par  . Évalué à 3 (+1/-0).

    En complément de ce super journal, une présentation découverte d'Elixir (utilisé la barre d'espace pour ne louper aucun slide).

  • # IA

    Posté par  . Évalué à 0 (+1/-2).

    Les IA commencent à bien maîtriser ce langage, ce qui n'était pas le cas il y a encore quelques mois.

  • # Elixir ♥

    Posté par  . Évalué à 4 (+2/-0). Dernière modification le 02 novembre 2026 à 23:47.

    J'en ai fait il y a quelques années ; j'avais adoré le paradigme, un petit peu moins la syntaxe1. Je te conseille vivement de t'intéresser aux GenServer, qui sont pour moi une vraie killer-feature2.

    De façon générale, l'écosystème Elixir / Erlang est vraiment très chouette.

    La seule chose qui me manquait vraiment, en dépit du pattern-matching sur les paramètres de fonctions et des guards, c'est un véritable système de typage statique. Dialyzer permettait d'ajouter des annotations de type, mais je n'étais vraiment pas fan. J'ai suivi de très loin, mais c'est quelque chose qui semble en cours d'implémentation3.

    C'est malin, je vais devoir m'y remettre.


    1. je ne suis pas fan des blocs do … end, et le sucre syntaxique est parfois un peu trop présent ↩

    2. https://elixir.hexdocs.pm/GenServer.html ↩

    3. https://elixir-lang.org/blog/2026/01/09/type-inference-of-all-and-next-15/ ↩

Envoyer un commentaire

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.