clojureCommencer avec clojure


Remarques

entrer la description de l'image ici

Clojure est un langage de programmation généraliste à typage dynamique avec syntaxe Lisp.

Ses fonctionnalités prennent en charge le style fonctionnel de programmation avec des fonctions de première classe et des valeurs immuables par défaut. L'utilisation de variables réaffectables n'est pas aussi facile dans Clojure que dans de nombreux langages traditionnels, car les variables doivent être créées et mises à jour comme des objets conteneurs. Cela encourage l'utilisation de valeurs pures qui resteront telles qu'elles étaient au moment où elles ont été vues pour la dernière fois. Cela rend généralement le code beaucoup plus prévisible, testable et compatible avec la concurrence. Cela fonctionne également pour les collections, car les structures de données intégrées de Clojure sont persistantes.

Pour des performances optimales, Clojure prend en charge les indices de type pour éliminer les réflexions inutiles lorsque cela est possible. En outre, des groupes de modifications de collections persistantes peuvent être apportées à des versions transitoires , ce qui réduit la quantité d'objets impliqués. Cela n'est pas nécessaire la plupart du temps, car les collections persistantes sont rapides à copier car elles partagent la plupart de leurs données. Leurs garanties de performance ne sont pas loin de leurs homologues mutables.

Clojure possède également:

  • mémoire transactionnelle logicielle (STM)
  • plusieurs primitives de concurrence n'impliquant pas de verrouillage manuel (atome, agent)
  • transformateurs de séquences composables (transducteurs),
  • installations de manipulation d'arbres fonctionnelles (fermetures éclair)

En raison de sa syntaxe simple et de son extensibilité élevée (via des macros, l'implémentation d'interfaces de base et la réflexion), certaines fonctionnalités de langage couramment rencontrées peuvent être ajoutées à Clojure avec des bibliothèques. Par exemple, core.typed apporte un vérificateur de type statique, core.async apporte des mécanismes de concurrence simples basés sur les core.logic , core.logic apporte la programmation logique.

Conçu comme un langage hébergé, il peut interagir avec la plate-forme sur laquelle il s'exécute. Bien que la cible principale soit JVM et l'écosystème entier derrière Java, d'autres implémentations peuvent également s'exécuter dans d'autres environnements, tels que ClojureCLR s'exécutant sur Common Language Runtime ou ClojureScript s'exécutant sur des environnements d'exécution JavaScript (y compris les navigateurs Web). Bien que certaines implémentations puissent ne pas avoir certaines fonctionnalités de la version JVM, elles sont toujours considérées comme une famille de langues.

Versions

Version Changer de journal Date de sortie
1.8 Dernier journal des modifications 2016-01-19
1,7 Changer le journal 1.7 2015-06-30
1.6 Changer le journal 1.6 2014-03-25
1.5.1 Changer le journal 1.5.1 2013-03-10
1.4 Changer le journal 1.4 2012-04-15
1.3 Changer de journal 1.3 2011-09-23
1.2.1 2011-03-25
1.2 2010-08-19
1.1 2010-01-04
1.0 2009-05-04

"Bonjour le monde!" dans le REPL

La communauté Clojure accorde une grande importance au développement interactif, de sorte qu'une interaction avec Clojure se produit dans une REPL (read-eval-print-loop) . Lorsque vous entrez une expression, Clojure la lit , l’ évalue et imprime le résultat de l’évaluation, le tout dans une boucle .

Vous devriez être en mesure de lancer une REPL Clojure maintenant. Si vous ne savez pas comment, suivez la section Installation et configuration de cette rubrique. Une fois que vous l'avez lancé, tapez ce qui suit:

(println "Hello, world!")
 

Puis appuyez sur Entrée . Cela devrait imprimer Hello, world! , suivi de la valeur de retour de cette expression, nil .

Si vous souhaitez lancer des actions instantanément, essayez REPL en ligne. Par exemple, http://www.tryclj.com/ .

"Bonjour le monde!" en utilisant Boot

Remarque: vous devez installer Boot avant d'essayer cet exemple. Voir la section Installation et configuration si vous ne l'avez pas encore installée.

Le démarrage permet de créer des fichiers Clojure exécutables en utilisant la ligne shebang (#!). Placez le texte suivant dans un fichier de votre choix (cet exemple suppose qu'il se trouve dans le "répertoire de travail actuel" et qu'il s'appelle hello.clj ).

#!/usr/bin/env boot

(defn -main [& args]
  (println "Hello, world!"))
 

Puis marquez-le comme exécutable (le cas échéant, généralement en exécutant chmod +x hello.clj ).
... et lancez-le ( ./hello.clj ).

Le programme devrait sortir "Hello, world!" et fini.

Créer une nouvelle application

Après avoir suivi les instructions ci-dessus et installé Leiningen, démarrez un nouveau projet en exécutant:

lein new <project-name>
 

Cela va configurer un projet Clojure avec le modèle Leiningen par défaut dans le dossier <project-name> . Il existe plusieurs modèles pour Leiningen, qui affectent la structure du projet. Le plus commun est le modèle "app" utilisé, qui ajoute une fonction principale et prépare le projet à être compressé dans un fichier jar (dont la fonction principale est le point d'entrée de l'application). Cela peut être réalisé en exécutant:

lein new app <project-name> 
 

En supposant que vous avez utilisé le modèle d'application pour créer une nouvelle application, vous pouvez tester que tout a été correctement configuré, en entrant le répertoire créé et en exécutant l'application en utilisant:

lein run
 

Si vous voyez Hello, World! sur votre console, vous êtes prêt et prêt à créer votre application.

Vous pouvez emballer cette application simple dans deux fichiers jar avec la commande suivante:

lein uberjar
 

Créer une nouvelle application (avec boot)

boot -d seancorfield/boot-new new -t app -n <appname>
 

Cette commande indiquera à boot de récupérer la tâche boot-new depuis https://github.com/seancorfield/boot-new et d'exécuter la tâche avec le template de l' app (voir le lien pour les autres templates). La tâche créera un nouveau répertoire appelé <appname> avec une structure d'application Clojure typique. Voir le README généré pour plus d'informations.

Pour exécuter l'application: boot run . Les autres commandes sont spécifiées dans build.boot et décrites dans le fichier README.

Installation et configuration

Option 1: Leiningen

Nécessite JDK 6 ou plus récent.

Le moyen le plus simple de commencer avec Clojure est de télécharger et d'installer Leiningen, l'outil standard de facto pour gérer les projets Clojure, puis d'exécuter lein repl pour ouvrir une REPL .

Linux

curl https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein > ~/bin/lein
export PATH=$PATH:~/bin
chmod 755 ~/bin/lein

OS X

Suivez les étapes ci-dessus pour Linux ou installez-les avec les gestionnaires de paquets macOS.

Installer avec Homebrew

brew install leiningen

Installer avec MacPorts

Installez d'abord Clojure

sudo port -R install clojure

Installez Leiningen , un outil de construction pour Clojure

sudo port -R install leiningen
lein self-install

les fenêtres

Voir la documentation officielle .

Option 2: Distribution officielle

Nécessite JRE 6 ou plus récent.

Les versions de Clojure sont publiées sous forme de simples fichiers JAR à exécuter sur la JVM. C'est ce qui se passe généralement dans les outils de construction Clojure.

  1. Allez sur http://clojure.org et téléchargez la dernière archive de Clojure

  2. Extrayez le fichier ZIP téléchargé dans un répertoire de votre choix

  3. Exécutez java -cp clojure-1.8.0.jar clojure.main dans ce répertoire

    Vous devrez peut-être remplacer le clojure-1.8.0.jar dans cette commande par le nom du fichier JAR que vous avez réellement téléchargé.

    Pour une meilleure expérience REPL en ligne de commande (par exemple, passer en rlwrap vos commandes précédentes), vous pouvez installer rlwrap : rlwrap java -cp clojure-1.8.0.jar clojure.main

Option 3: démarrage

Nécessite JDK 7 ou plus récent.

Boot est un outil de construction Clojure polyvalent. Comprendre cela nécessite une certaine connaissance de Clojure, donc ce n'est peut-être pas la meilleure option pour les débutants. Consultez le site Web (cliquez sur Démarrer ) pour obtenir des instructions d'installation.

Une fois installé et dans votre PATH , vous pouvez exécuter boot repl n'importe où pour démarrer une REPL Clojure.