Clojure

Clojure
Date de première version	2007
Paradigmes	fonctionnel, multi-paradigme
Auteur	Rich Hickey
Développeurs	Rich Hickey
Dernière version	1.12.1 (2 juin 2025)[1]
Typage	fort, dynamique
Influencé par	ML Common Lisp Lisp
A influencé	Pixie, Rhine, Elixir
Écrit en	Java
Système d'exploitation	JVM, Node.js, CLR
Licence	Licence Eclipse[2]
Site web	clojure.org
Extension de fichier	clj, cljs, cljc, edn et cljr
modifier

Clojure est un langage de programmation fonctionnelle compilé, multi-plateforme et destiné à la création de programmes sûrs et facilement distribuables. C’est un dialecte de Lisp. Il transpile vers du bytecode Java, du code JavaScript et du bytecode .NET. Clojure est donc disponible sur la JVM, le CLR, les navigateurs et Node.js.

Rich Hickey est le créateur du langage Clojure^[3]. Avant Clojure, il a développé dotLisp, un projet similaire basé sur la plate-forme .NET^[4], et trois tentatives antérieures pour assurer l'interopérabilité entre Lisp et Java : une "interface Java en langue étrangère pour Common Lisp" (Java foreign language interface for Common Lisp, jfli)^[5], une "interface pour objets étrangers pour Lisp" (Foreign Object Interface for Lisp, FOIL)^[6] et une "interface conviviale pour Lisp pour les servlets Java" (Lisp-friendly interface to Java Servlets, Lisplets)^[7].

Hickey a passé environ deux ans et demi à travailler sur Clojure avant de le rendre public, une grande partie de ce temps travaillant exclusivement sur Clojure sans aucun financement extérieur. À la fin de cette période, Hickey a envoyé un courriel annonçant le langage à quelques amis de la communauté Common Lisp.

Le processus de développement est mené par la communauté^[8] et est géré à la page du projet JIRA Clojure^[9] où les problèmes peuvent être soumis. Les discussions générales sur le développement se déroulent au sein du Clojure Google Group^[10]. Tout le monde peut soumettre des problèmes et des idées, mais pour contribuer aux correctifs, il faut signer le Clojure Contributor agreement^[11]. Les problèmes sur le JIRA sont traités par une équipe d'examinateurs et finalement Rich Hickey approuve les changements^[12].

Le nom "Clojure", selon Hickey, est un jeu de mots sur le concept de "fermeture" dans la programmation (en anglais, closure), qui incorpore les lettres C, L et J pour C#, Lisp et Java respectivement - trois langages qui ont eu une influence majeure sur la conception de Clojure^[13].

Rich Hickey a développé Clojure parce qu’il voulait un Lisp moderne pour la programmation fonctionnelle, en symbiose avec la plateforme Java, et expressément orienté vers la programmation concurrente.

L’approche concurrentielle de Clojure est caractérisée par le concept d’identité^[14], qui représente une série d’états immuables dans le temps. Comme les états sont des valeurs fixes, un nombre indéfini d’agents peut y accéder en parallèle, et la concurrence se résume alors à gérer les changements d’un état à un autre. Dans cette optique, Clojure propose plusieurs types de références mutables, chacun d’eux ayant une sémantique bien définie pour la transition inter-états.

Clojure considère les collections comme des séquences, et encourage la création de programmes consommant et produisant des séquences plutôt que des instances de classes. Cela permet de définir un programme en termes d’abstraction. Le programmeur ne se soucie pas de la façon dont un vecteur, une liste ou tout autre type de collection doit être itérée pour exprimer sa logique.

• Développement dynamique à l’aide du REPL (en)
• Les fonctions sont des objets. La programmation par récursion est favorisée, plutôt que la programmation par boucle à effets de bord. La récursion terminale est supportée via le verbe recur
• Séquences évaluées paresseusement
• Structures de données non mutables et persistantes
• Programmation concurrente grâce à la STM, à un système d’agents, et à un système de variables dynamiques
• Intégration au langage : en compilant en code binaire pour la machine virtuelle Java, les applications en Clojure sont préparées et déployées dans la JVM ou un serveur d’application sans difficulté supplémentaire. Le langage fournit aussi des macros qui facilitent l’usage des API Java existantes. Les structures de données de Clojure implémentent toutes des interfaces Java standardisées, rendant aisée l’exécution de code écrit en Clojure depuis Java. Il en va de même avec les autres cibles de compilation.

Les deux dépôts principaux sont les dépôts d’Apache Maven et Clojars. Comme Clojure est rétrocompatible avec Java, les dépendances sont traitées de la même façon que dans un projet Maven classique. Il est également possible d’importer un .jar quelconque en l’ajoutant simplement au classpath.

Bien qu’il soit possible de créer des programmes Clojure avec Maven, Leiningen est plus utilisé (à plus de 97 %^[15]). Leiningen fournit un meilleur REPL et facilite davantage l’automatisation des tâches de base. Exemple de dépendances avec Sparkling, un connecteur pour Apache Spark :

Leiningen

[gorillalabs/sparkling "1.2.5"]

Maven

<dependency>
  <groupId>gorillalabs</groupId>
  <artifactId>sparkling</artifactId>
  <version>1.2.5</version>
</dependency>

Clojure est lui-même une dépendance du projet, se présentant comme un simple fichier .jar . Il suffit de modifier la version de la dépendance dans le fichier pom.xml ou project.clj et de relancer l’application pour exécuter le programme sur une autre version de Clojure.

Comme n’importe quel autre Lisp, la syntaxe de Clojure est basée sur les S-expressions. Ces dernières sont d’abord parsées en structures de données par un reader (en), avant d’être compilées. Clojure est un Lisp-1, et n’a pas pour objectif d’être compatible avec d’autres dialectes de Lisp.

Contrairement à d’autres Lisp, Clojure permet la représentation directe de certaines structures : vecteurs, tables de hachage, ensembles. Ceci rend aussi naturelle l’utilisation de ces structures en Clojure que les listes dans les autres Lisp.

Les commentaires commencent par deux points-virgules :

;; Ceci est donc un commentaire

Les crochets déclarent un vecteur, ici un vecteur d’entiers :

[1 2 3]

Les parenthèses, une liste chaînée :

'(1 2 3 4 5)

Le simple quote précédant la parenthèse est un caractère d’échappement (voir cette section). Le deux-points, suivi d’un nom, déclare un mot clef. Les mots clefs sont des chaînes de caractères internées et comparables par adresse. Les mots clefs sont souvent utilisés comme clefs dans les tables de hachage, ou comme remplacement des énumérations.

:mot-clef

:chat :chien :lapin

:administrateur :utilisateur :invité

Les accolades déclarent une table de hachage (ou map) :

{:nom "Clojure"
 :type :langage
 :famille :lisp
 :auteur "Rich Hickey"}

Les chaînes de caractères, délimitées par les guillemets anglais (ou double quotes), peuvent s'étendre sur plusieurs lignes.

"Une chaîne
 sur plusieurs
 lignes"

Le croisillon suivi d’accolades déclare un ensemble (ou set), ici un ensemble hétérogène :

#{1 2 3 :quatre "cinq" 6.0}

Clojure est un langage homoiconique (il s’écrit via ses propres structures de données). Un appel de fonction est donc fait d’une liste.

(+ 1 2 3)

Ici la fonction + reçoit trois arguments et retourne la somme de ses arguments (6). Une liste peut contenir des sous-listes, formant ainsi des arbres.

(str "Résultat : " (+ 3 (/ (- 10 1) 2)))

;; => "Résultat : 15/2"

Cet appel de fonction retourne « Résultat : 15/2 ». En effet, Clojure possède un type Ratio.

+, -, *, /, etc. ne sont pas des opérateurs, mais bien des fonctions. Il n’y a donc pas de priorité entre les opérateurs, car il n’y a pas d’opérateurs et car la syntaxe est toujours explicite.

Le code (+ 1 2 3) est un appel de fonction. Le code (1 2 3) est une déclaration de liste chaînée. Écrire (1 2 3) dans un REPL ou dans un programme provoquera une erreur car le compilateur tentera de faire référence au premier élément de la liste (1) en tant que fonction. Or 1 est un entier. Il faut donc échapper la liste chaînée en utilisant un simple quote ' . La bonne syntaxe est donc '(1 2 3) .

En Clojure, une fonction est un objet d’une classe implémentant l’interface IFn . C’est le cas des mots-clefs. Les appeler en tant que fonction sert à extraire des données d’une table de hachage.

;; déclaration d’une map nommée "ma-table"
(def ma-table {:nom "banane"
               :type :fruit
               :prix 0.50})
           
(:nom ma-table)
;; => "banane"

(:prix ma-table)
;; => 0.5

Ce code est équivalent :

(get ma-table :nom)
;; => "banane"

(get ma-table :prix)
;; => 0.5

Les espaces de nommage (namespaces) permettent de structurer le code en modules (similaires au packages en Java). La notation est constante et explicite. Le nom du namespace est en minuscule, les sous-namespaces sont séparés par un . . Le / sépare le namespace de son contenu. Par exemple la fonction split du namespace clojure.string se note clojure.string/split .

La déclaration d’un namespace suit les mêmes règles que pour les classes en Java : un namespace par fichier et un fichier par namespace.

Un namespace se déclare via ns, les namespaces peuvent être importés partiellement ou être aliasés. Voici un exemple de namespace fournissant une fonction estMineur et son complément estMajeur :

;; déclaration du namespace nommé utilisateurs.validation
(ns utilisateurs.validation
    
    ;; chargement du namespace clojure.string, aliasé en 's'
    (:require [clojure.string :as s]))

;; Une fonction se déclare avec 'defn'

(defn estMineur
    "Ceci est une docstring.
    Cette fonction indique si l’âge donné
    correspond à un mineur ou non."
    [age]
    (< age 18))  ;; la dernière valeur de l’arbre est retournée


;; définition du complément
(def estMajeur (complement estMineur))


(defn formater-message
    "Affiche un message lisible indiquant si 
    l’utilisateur est majeur ou mineur."
    [utilisateur]
    (println
        (s/capitalize 
            (str "bonjour " (:nom utilisateur)
                 " vous êtes "
                 (if (estMajeur (:age utilisateur))
                     "majeur"
                     "mineur")
                  "."))))

(formater-message {:nom "Pierre" :age 12})

;; => Bonjour Pierre vous êtes mineur.

Le système de macro de Clojure est semblable à celui que propose Common Lisp, exception faite de l’apostrophe inversée (backquote), appelée « apostrophe de syntaxe » (syntax quote) qui associe un symbole à son espace de nommage.

Il est par exemple possible de réécrire la fonction formater-message bien plus proprement grâce à une macro : la threading macro :

(defn formater-message
    [utilisateur]
    (->
        (str "bonjour " (:nom utilisateur)
             " vous êtes "
             (if (estMajeur (:age utilisateur)) "majeur" "mineur")
             ".")
         (s/capitalize)
         (println)))

La macro threading-first -> insère en seconde position (premier argument) le résultat de l’application de fonction précédente. Cela permet de composer les fonctions sous forme d’une liste d’étapes à exécuter séquentiellement.

Bien que la JVM soit la cible de compilation principale, ClojureScript permet de compiler du code Clojure en JavaScript. Le code produit est alors compatible avec les navigateurs supportant la norme ECMAScript 3+ et Node.js.

Clojure se veut symbiotique avec sa plateforme et ne tente pas de cacher les fonctionnalités natives de celle-ci. Clojure permet donc, via des fichiers .cljc de définir des règles de compilation. Il est très courant de trouver des bibliothèques compatibles avec plus d’une plateforme.

Créer un nouveau programme avec Leiningen et lancer le REPL :

> lein new app nom-du-programme
> cd nom-du-programme
> lein repl

Hello world :

(println "Bonjour tout le monde !")

Hello world dans une interface graphique Swing :

(javax.swing.JOptionPane/showMessageDialog nil "Bonjour tout le monde !")

Ou encore :

(ns wikipedia.core 
    (:import (javax.swing JOptionPane)))

(JOptionPane/showMessageDialog nil "Bonjour tout le monde !")

;; Affiche "Bonjour le monde" dans la console du navigateur
(.log js/console "Bonjour le monde")

;; En utilisant alert
(js/alert "Bonjour le monde")

Le développement en Clojure a bénéficié d’une nette progression de l'offre au fil des années^[16]. La liste suivante détaille quelques environnements de développement (IDE) et éditeurs de texte majeurs supportant le développement en Clojure :

• Emacs, avec CIDER^[17]
• IntelliJ IDEA, avec Cursive^[18] (gratuit pour usage non commercial)
• Sublime Text, avec Clojure Sublimed^[19] ou Tutkain^[20]
• Vim, avec fireplace.vim^[21], vim-elin^[22] ou Conjure^[23] (Neovim uniquement)
• Visual Studio Code, avec Calva^[24] ou Clover^[25]
• Indépendant de l’IDE (via le Language Server Protocol pour l’analyse statique et/ou le linting) : clj-kondo^[26] ou clojure-lsp^[27]

Selon le sondage State of Clojure 2024, l'environnement le plus utilisé pour développer en Clojure est Emacs/CIDER, suivi par IntelliJ IDEA et Visual Studio Code^[16].

La programmation fonctionnelle gagnant en popularité, Clojure se rencontre fréquemment auprès des développeurs Java^[28]. Le langage bénéficie du soutien de personnalités influentes du monde du développement, comme Brian Goetz^[29], Eric Evans^[30],[31], James Gosling (créateur de Java)^[32], Paul Graham^[33] ou encore Robert C. Martin^{[34],[35],[36],[37]}. En 2010, ThoughtWorks qualifiait Clojure de « Lisp simple et élégant pour la JVM » dans son magazine en ligne Technology Radar^[38], avant de le recommander officiellement à l’adoption en 2012^[39].

D’après le JVM Ecosystem Report 2018 — présenté comme la plus vaste enquête jamais menée auprès de développeurs Java — Clojure se classait alors au deuxième rang des langages les plus utilisés sur la JVM pour le développement d'applications principales, après Java mais avant Kotlin^[40].

De nombreuses entreprises de renom font appel à Clojure^[41], parmi lesquelles Apple^[42],[43], Atlassian^[44], Funding Circle^[45], Netflix^[46], Nubank^[47] ou encore Walmart^[48], ainsi que certaines institutions comme la NASA^[49]. Le langage est aussi utilisé dans des projets de création numérique : arts visuels, musique, ou encore jeux vidéo^[50].

Selon l’édition 2023 de l’enquête annuelle Stack Overflow Developer Survey, Clojure figurait parmi les langages de programmation les plus appréciés : près de 69 % des développeurs l’ayant utilisé l'année précédente déclaraient vouloir continuer à travailler avec. En revanche, ils n’étaient que 2,2 % à exprimer le souhait de s’y mettre, loin derrière JavaScript, plébiscité par plus de 40 % des répondants^[51].

• Site officiel
• Documentation collaborative

• Portail de la programmation informatique