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
- Correspondance de motifs (ou Pattern matching)
- Module, fonctions et clauses de garde
- Listes et récursivité
- L'opérateur pipe
- L'exercice sympa qui utilise tout ça (ou presque)
- Et maintenant
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
- Site officiel du langage Elixir (98 clics)

# Syntaxe similaire à Ruby
Posté par Gawan . É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:
💡
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 Stéphane Bortzmeyer (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 David Delassus (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
[^] # Re: Syntaxe similaire à Ruby
Posté par devnewton 🍺 (site web personnel) . Évalué à 4 (+1/-0).
Tu sais tout ce qu'il y a savoir : la syntaxe est horrible !
Ce post est offensant ? Prévenez moi sur https://linuxfr.org/board
# Parallélisme
Posté par Stéphane Bortzmeyer (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 arnaudus . É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 Colin Pitrat (site web personnel) . Évalué à 7 (+5/-0).
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 Stéphane Bortzmeyer (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 arnaudus . Évalué à -2 (+0/-5).
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.
[^] # Re: Les langages...
Posté par Thomas J. (site web personnel) . Évalué à 5 (+4/-0).
Qu'on l'utilise ou non, je ne pense pas qu'on puisse considérer [[https://fr.wikipedia.org/wiki/WhatsApp]] comme un programme de niche…
[^] # Re: Les langages...
Posté par Stéphane Bortzmeyer (site web personnel, Mastodon) . Évalué à 5 (+3/-0).
Marrant, j'avais justement cité des exemples.
# présentation
Posté par steph1978 . É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 ptit_poulet . É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 Letho . É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.
je ne suis pas fan des blocs
do … end, et le sucre syntaxique est parfois un peu trop présent ↩https://elixir.hexdocs.pm/GenServer.html ↩
https://elixir-lang.org/blog/2026/01/09/type-inference-of-all-and-next-15/ ↩
[^] # Re: BEAM (VM d'Erlang et compagnie) et typage
Posté par nspanti . Évalué à 6 (+6/-0).
Il y aurait Gleam pour avoir une sorte d'Elixir avec typage.
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.