Différences avec les autres LISP

Ces informations sont destinées aux programmeurs connaissant Common Lisp ou Scheme :

• Clojure est sensible à la casse.
• Clojure est un Lisp-1.
• () n'est pas équivalent à nil.
• Le lecteur est sans effet de bord.
• Les mots-clefs ne sont pas des symboles.
• Les symboles ne sont pas des emplacements d'entreposage (voir Var).
• nil n'est pas un symbole.
• t n'est pas une syntaxe ; utilisez true.
• La table de lecture n'est pas accessible aux programmes utilisateurs.
• let effectue des liaisons séquentielles.
• do n'est pas une boucle.
• Il n'y a pas d'optimisation des appels terminaux ; utilisez recur.
• Syntax-quote effectue la résolution des symboles ; donc `x` n'est pas équivalent à 'x.
• ` possède auto-gensyms.
• Le symbole ~ représente un guillemet non signé, et le symbole d'espacement est utilisé.
• Il existe une syntaxe de lecture pour les cartographies, les vecteurs et les ensembles.
• Les fonctions `cons`, `first` et `rest` manipulent des abstractions de séquences, et non des cellules `cons` concrètes.
• La plupart des structures de données sont immuables.
• Lambda est une fonction (`fn`) et supporte la surcharge par arité.
• Le symbole `=` est le prédicat d'égalité.
• Les variables globales peuvent être redéfinies dynamiquement (si elles sont déclarées dynamiques) sans interférer avec les liaisons locales lexicales. Aucune déclaration spéciale n'est nécessaire pour distinguer les liaisons dynamiques des liaisons lexicales. Clojure étant un Lisp-1, les fonctions (globales) peuvent être redéfinies dynamiquement (si elles sont marquées comme dynamiques).
• Pas de `letrec`, d'étiquettes ni de `flet` : utilisez `(fn nom [args]...)` pour l'auto-référence et `letfn` pour la référence mutuelle.
• En Clojure, `nil` signifie « rien ». Il indique l'absence de valeur, quel que soit son type, et n'est pas spécifique aux listes ou aux séquences.
• Les collections vides sont différentes de `nil`. Clojure n'assimile pas `nil` à `()`.
• `false` représente l'une des deux valeurs booléennes possibles, l'autre étant `true`.
• Les collections ne se limitent pas aux listes. Il existe des collections vides, dont certaines sont représentées par des littéraux (`[]`, `{}` et `()`). Il ne peut donc pas y avoir de valeur sentinelle pour une collection vide.
• En Scheme, `nil` correspond probablement le mieux à votre notion de `#f`.
• Une différence majeure en Clojure réside dans les séquences. Les séquences ne sont pas des collections spécifiques, et notamment pas nécessairement des listes concrètes. Lorsqu'on demande à une collection vide une séquence de ses éléments (en appelant `seq`), elle renvoie `nil`, indiquant qu'elle ne peut pas en produire une. Lorsqu'on demande à une séquence, à partir de son dernier élément, les éléments restants, elle renvoie une autre séquence logique. On ne peut déterminer si cette séquence est vide qu'en appelant `seq` dessus. Cela permet aux séquences et au protocole de séquence d'être paresseux.
• Certaines fonctions de séquence correspondent à des fonctions de Scheme et CL qui manipulaient uniquement des paires/consonnes (« listes ») et renvoyaient des valeurs sentinelles (« () » et « nil ») représentant des listes « vides ». Les valeurs de retour de Clojure diffèrent en ce qu'elles ne renvoient pas de collections vides spécifiques, mais plutôt une autre séquence logique. Certaines fonctions de séquence n'ont pas d'équivalent en Scheme/CL et correspondent à des fonctions de type Haskell/ML. Certaines de ces fonctions renvoient des séquences infinies ou calculées, où l'analogie avec des structures de données concrètes comme les listes Scheme/CL est pour le moins ténue.
• Il est utile de distinguer les collections/structures de données et les séquences/itérations. En CL et Scheme, ces notions sont confondues, tandis qu'en Clojure, elles sont distinctes.