Clojure

Clojure ( / ˈ k l oʊ ʒ ər / , comme fermeture ) est un dialecte dynamique et fonctionnel du langage de programmation Lisp sur la plate-forme Java .

Comme la plupart des autres Lisp, la syntaxe de Clojure est construite sur des expressions S qui sont d'abord analysées en structures de données par un lecteur Lisp avant d'être compilées . Le lecteur de Clojure prend en charge la syntaxe littérale pour les cartes , les ensembles et les vecteurs ainsi que les listes, et ceux-ci sont compilés directement dans les structures mentionnées. Clojure traite le code comme des données et dispose d'un système de macros Lisp . Clojure est un Lisp-1 et n'est pas destiné à être compatible avec le code d'autres dialectes de Lisp, car il utilise son propre ensemble de structures de données incompatibles avec d'autres Lisp.

Clojure prône l'immuabilité et les structures de données immuables et encourage les programmeurs à être explicites sur la gestion de l'identité et de ses états. Cette focalisation sur la programmation avec des valeurs immuables et des constructions explicites de progression du temps vise à faciliter le développement de programmes plus robustes, en particulier concurrents , qui sont simples et rapides. Bien que son système de types soit entièrement dynamique , des efforts récents ont également cherché à mettre en œuvre un système de types dépendant .

Le langage a été créé par Rich Hickey au milieu des années 2000, à l'origine pour la plateforme Java ; le langage a depuis été porté sur d'autres plateformes, telles que Common Language Runtime (.NET). Hickey continue de diriger le développement du langage en tant que dictateur bienveillant à vie .

Rich Hickey est le créateur du langage Clojure. Avant Clojure, il a développé dotLisp, un projet similaire basé sur la plate-forme .NET , et trois tentatives antérieures pour assurer l'interopérabilité entre Lisp et Java : une interface de langage étranger Java pour Common Lisp ( jfli), A Foreign Object Interface for Lisp (FOIL), et une interface conviviale pour Lisp pour les servlets Java (Lisplets).

Hickey a passé environ deux ans et demi à travailler sur Clojure avant de le publier publiquement en octobre 2007, la plupart du temps en travaillant exclusivement sur Clojure sans aucun financement extérieur. À la fin de cette période, Hickey a envoyé un e-mail annonçant le langage à certains amis de la communauté Common Lisp.

Le nom de Clojure, selon Hickey, est un jeu de mots sur le concept de programmation « fermeture » incorporant 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.

Rich Hickey a développé Clojure parce qu'il voulait un Lisp moderne pour la programmation fonctionnelle , symbiotique avec la plate-forme Java établie et conçu pour la concurrence . Il a également souligné l'importance de la simplicité dans la conception du langage de programmation et de l'architecture logicielle, en préconisant un couplage lâche , le polymorphisme via des protocoles et des classes de types au lieu de l'héritage , des fonctions sans état qui sont des espaces de noms au lieu de méthodes ou le remplacement de la syntaxe par des données .

L'approche de Clojure en matière d'état est caractérisée par le concept d'identités, qui sont représentées comme une série d'états immuables au fil du temps. Étant donné que les états sont des valeurs immuables, n'importe quel nombre de travailleurs peut les exploiter en parallèle, et la concurrence devient une question de gestion des changements d'un état à un autre. À cette fin, Clojure fournit plusieurs types de référence mutables , chacun ayant une sémantique bien définie pour la transition entre les états.

Clojure fonctionne sur la plateforme Java et s'intègre donc à Java et prend entièrement en charge l'appel de code Java depuis Clojure, et le code Clojure peut également être appelé depuis Java. La ​​communauté utilise des outils tels que l'interface de ligne de commande Clojure (CLI) ou Leiningen pour l'automatisation des projets, offrant un support pour l'intégration Maven . Ces outils gèrent la gestion des packages de projet et les dépendances et sont configurés à l'aide de la syntaxe Clojure.

En tant que dialecte Lisp, Clojure prend en charge les fonctions en tant qu'objets de première classe , une boucle lecture-évaluation-impression (REPL) et un système de macros. de macros Lisp de Clojure est très similaire à celui de Common Lisp à l'exception du fait que la version de Clojure du backquote (appelé « guillemet de syntaxe ») qualifie les symboles avec leur espace de noms . Cela permet d'éviter la capture de noms involontaire, car la liaison à des noms qualifiés par un espace de noms est interdite. Il est possible de forcer une expansion de macro de capture, mais cela doit être fait explicitement. Clojure n'autorise pas les macros de lecture définies par l'utilisateur, mais le lecteur prend en charge une forme plus restreinte d'extension syntaxique. Clojure prend en charge les multiméthodes et pour les abstractions de type interface, dispose d'un protocole basé sur le polymorphisme et d'un système de types de données utilisant des enregistrements , fournissant un polymorphisme dynamique et à hautes performances conçu pour éviter le problème d'expression .

Clojure prend en charge les séquences paresseuses et encourage le principe d' immuabilité et les structures de données persistantes . En tant que langage fonctionnel , l'accent est mis sur la récursivité et les fonctions d'ordre supérieur plutôt que sur les boucles basées sur les effets secondaires. L'optimisation automatique des appels de queue n'est pas prise en charge car la JVM ne la prend pas en charge nativement ; il est possible de le faire explicitement en utilisant le recurmot-clé. Pour la programmation parallèle et concurrente , Clojure fournit une mémoire transactionnelle logicielle , système d'agent réactif , et une programmation concurrente basée sur les canaux .

Clojure 1.7 a introduit les conditions de lecture en permettant l'intégration de code Clojure, ClojureScript et ClojureCLR dans le même espace de noms. Les transducteurs ont été ajoutés comme méthode de composition de transformations. Les transducteurs permettent aux fonctions d'ordre supérieur telles que map et fold de généraliser sur n'importe quelle source de données d'entrée. Alors que traditionnellement ces fonctions fonctionnent sur des séquences , les transducteurs leur permettent de travailler sur des canaux et permettent à l'utilisateur de définir ses propres modèles de transduction.

Extensible Data Notation , ou edn , est un sous-ensemble du langage Clojure conçu comme un format de transfert de données. Il peut être utilisé pour sérialiser et désérialiser les structures de données Clojure, et Clojure lui-même utilise un sur-ensemble d'edn pour représenter les programmes.

edn est utilisé de manière similaire à JSON ou XML , mais dispose d'une liste relativement longue d'éléments intégrés, présentés ici avec des exemples :

• booléens : true,false
• chaînes:"foo bar"
• personnages: \c, ab
• symboles:name
• mots-clés::key
• entiers:123
• nombres à virgule flottante :3.14
• listes:(a b 42)
• vecteurs:[a b 42]
• cartes:{:a 1, "foo" :bar, [1 2 3] four}
• ensembles:#{a b [1 2 3]}
• nil : nil(une valeur de type null )

En plus de ces éléments, il prend en charge l'extensibilité grâce à l'utilisation de balises , qui se composent du caractère #suivi d'un symbole. Lorsqu'il rencontre une balise, le lecteur transmet la valeur de l'élément suivant au gestionnaire correspondant, qui renvoie une valeur de données. Par exemple, il peut s'agir d'un élément balisé : #myapp/Person {:first "Fred" :last "Mertz"}, dont l'interprétation dépendra du gestionnaire approprié du lecteur.

Cette définition des éléments d'extension en termes des autres évite de s'appuyer sur une convention ou un contexte pour transmettre des éléments non inclus dans l'ensemble de base.

La plate-forme principale de Clojure est Java , mais d'autres implémentations cibles existent. La plus notable d'entre elles est ClojureScript, qui compile en ECMAScript 3, et ClojureCLR, un portage complet sur la plate-forme .NET , interopérable avec son écosystème.

D'autres implémentations de Clojure sur différentes plateformes incluent :

• Babashka, Langage de script Clojure natif exploitant l'image native GraalVM et le petit interpréteur Clojure
• CljPerl, Clojure sur Perl
• ClojureDart, Étendez la portée de Clojure aux applications mobiles et de bureau en portant Clojure sur Dart et Flutter
• Clojerl, Clojure sur BEAM , la machine virtuelle Erlang
• basilisp, Un dialecte Lisp compatible Clojure (-ish) ciblant Python 3.8+
• ClojureRS, Clojure sur Rust
• Ferret, compile en C++11 autonome qui peut s'exécuter sur des microcontrôleurs
• jank, Clojure natif hébergé en C++ sur un JIT basé sur LLVM
• Joker, un interpréteur et linter écrit en Go
• Las3r, un sous-ensemble de Clojure qui s'exécute sur la machine virtuelle ActionScript (la plate-forme Adobe Flash Player)
• Pixie, Dialecte Lisp inspiré de Clojure écrit en RPython
• Rouge, Clojure sur YARV en Ruby

Les outils de développement Clojure ont connu des améliorations significatives au fil des ans. Voici une liste de certains IDE et éditeurs de texte populaires avec des plug-ins qui prennent en charge la programmation en Clojure :

• Emacs , avec CIDER
• IntelliJ IDEA , avec Cursive (une licence gratuite est disponible pour une utilisation non commerciale )
• Sublime Text , avec Clojure Sublimed, ou Tutkain,
• Vim , avec fireplace.vim, vim-elin, ou Conjure (Neovim uniquement)
• Visual Studio Code , avec Calva ou Clover
• Indépendant de l'IDE (utilisant le protocole Language Server pour l'analyse statique et/ou le linting ) : clj-kondo ou clojure-lsp

En plus des outils fournis par la communauté, les outils officiels d'interface de ligne de commande (CLI) Clojure sont également disponibles sur Linux , macOS et Windows depuis Clojure 1.9.

Le processus de développement est limité à l'équipe principale de Clojure, bien que les problèmes soient visibles publiquement sur la page du projet Clojure JIRA . N'importe qui peut poser des questions ou soumettre des problèmes et des idées sur ask.clojure.org. S'il est déterminé qu'un nouveau problème justifie un ticket JIRA, un membre de l'équipe principale le triera et l'ajoutera. Les problèmes JIRA sont traités par une équipe de sélectionneurs et finalement approuvés par Rich Hickey.

Avec l'intérêt continu pour la programmation fonctionnelle, l'adoption de Clojure par les développeurs de logiciels utilisant la plate-forme Java a continué d'augmenter. Le langage a également été recommandé par des développeurs de logiciels tels que Brian Goetz, Eric Evans, James Gosling , Paul Graham , et Robert C. Martin . ThoughtWorks , lors de l'évaluation des langages de programmation fonctionnelle pour leur Technology Radar, a décrit Clojure comme « une implémentation simple et élégante de Lisp sur la JVM » en 2010 et a promu son statut à « ADOPT » en 2012.

Dans le « JVM Ecosystem Report 2018 » (qui a été présenté comme « la plus grande enquête jamais réalisée auprès des développeurs Java »), préparé en collaboration par Snyk et Java Magazine, Clojure a été classé comme le deuxième langage de programmation le plus utilisé sur la JVM pour les « applications principales ». Clojure est utilisé dans l'industrie par des entreprises telles qu'Apple , [ Atlassian , Funding Circle , Netflix , Nubank , Puppet , et Walmart ainsi que par des agences gouvernementales telles que la NASA . Il a également été utilisé pour l'informatique créative, notamment les arts visuels, la musique, les jeux et la poésie.

Dans l'édition 2023 de l'enquête auprès des développeurs de Stack Overflow , Clojure était le quatrième langage le plus admiré dans la catégorie des langages de programmation et de script, avec 68,51 % des répondants qui ont travaillé avec lui l'année dernière déclarant qu'ils aimeraient continuer à l'utiliser. Dans la catégorie souhaitée , cependant, il n'a été marqué comme tel que par seulement 2,2 % des personnes interrogées, tandis que le JavaScript ayant obtenu le score le plus élevé était souhaité par 40,15 % des développeurs participant à l'enquête.