Clojure

Rich Hickey, créateur de Clojure

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 de la 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.

[gorillalabs/sparkling "1.2.5"]

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

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.

;; Ceci est donc un commentaire

[1 2 3]

'(1 2 3 4 5)

:mot-clef

:chat :chien :lapin

:administrateur :utilisateur :invité

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

"Une chaîne
 sur plusieurs
 lignes"

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

(+ 1 2 3)

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

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

;; 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

(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

(println "Bonjour tout le monde !")

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

(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")

• Site officiel
• Documentation collaborative

• Portail de la programmation informatique