Présentation de Clojure

Clojure, apparu en 2007, s’inscrit dans la famille Lisp aux côtés de Common Lisp, Scheme et Racket. Le langage est dynamique, avec un système de typage optionnel qui laisse le développeur choisir entre vérifications à l’exécution ou, via clojure.spec ou core.typed, des contrôles statiques limités. Son environnement REPL permet d’écrire, tester et ajuster le code de façon interactive, ce qui modifie la manière de concevoir les algorithmes dès les premières lignes.

Mécanismes de macros et de code‑as‑data

La syntaxe uniforme de Clojure repose sur des listes S‑expressions, ce qui rend chaque fragment de code manipulable comme une structure de données. Les macros, implémentées directement dans le langage, transforment ces listes avant la compilation. Cette capacité oblige le programmeur à raisonner sur le code comme sur des données, un principe appelé « code‑as‑data ». Un exemple concret est le macro ->> utilisé dans l’enchaînement de fonctions, qui réécrit le flux de données de façon lisible et extensible.

(defn revenue-by-department [carts]
  (->> (filter :settled? carts)
       (mapcat :line-items)
       (map line-summary)
       (group-by :dept)
       (reduce-kv dept-total)))

Cette fonction montre comment les séquences, les filtres et les agrégations s’enchaînent sans syntaxe supplémentaire, rappelant le style des requêtes SQL tout en restant purement fonctionnelle.

Structures de données persistantes et parallélisme

Clojure intègre des structures persistantes – listes, vecteurs, maps – qui conservent les versions antérieures après chaque modification. Les vecteurs persistants, issus de recherches des années 1990, offrent un accès en temps constant et une insertion amortie, tout en restant immuables. Cette immutabilité simplifie la programmation multithread : aucune synchronisation explicite n’est requise, car les threads ne peuvent pas altérer les mêmes instances.

Le langage propose plusieurs abstractions de parallélisme. Les reducers et transducers permettent de transformer des flux de données de façon composable et de les exécuter en parallèle sans créer de collections intermédiaires. core.async reproduit le modèle CSP de Go via des macros, offrant des canaux et des go‑blocks qui facilitent la coordination asynchrone.

Gestion du typage et des protocoles

Bien que fondamentalement dynamique, Clojure offre des mécanismes de typage optionnel. clojure.spec décrit la forme attendue des structures imbriquées, génère des tests de conformité et produit des messages d’erreur détaillés. Pour les projets nécessitant une vérification plus stricte, core.typed ajoute un système de types statiques compatible avec le reste du langage.

Le modèle d’objets repose sur les protocols, analogues aux interfaces de Go. Un protocole définit un ensemble de fonctions que différents types peuvent implémenter, permettant le dispatch multiple sans hiérarchie de classes. Cette approche décourage les dépendances cycliques et favorise la composition de comportements.