Signification de # en clojure

Il existe également des ensembles # {} , des constructeurs de noms de classes complets # my.klass_or_type_or_record [: a: b: c] , instants #inst " aaaa-mm-jjThh: mm: ss.fff + hh: mm " et quelques autres .

Ils sont liés dans un sens qui, dans ces cas, # démarre une séquence reconnaissable par clojure reader , qui envoie chaque instance de ce type à un lecteur approprié. Il existe un guide qui développe cela.

Je pense que cette convention existe pour réduire le nombre de syntaxes différentes à une seule et ainsi simplifier le lecteur.

Ces deux # sont-ils liés?

Non, ils ne le sont pas. Le littéral # est utilisé de différentes manières. Certains d'entre eux que vous avez déjà mentionnés: ce sont une fonction anonyme et un modèle de regex. Voici quelques autres cas:

• Le fait de faire précéder une expression de #_ l'efface simplement du compilateur car elle n'a jamais été écrite. Par exemple: #_ (/ 0 0) sera ignoré au niveau du lecteur donc aucune exception n'apparaîtra.

• Le marquage des primitives pour les contraindre à des types complexes, par exemple #inst "2019-03-09" produira une instance de java.util.Date classe. Il existe également #uuid et d'autres balises intégrées. Vous pouvez enregistrer les vôtres.

• Marquer des cartes ordinaires pour les contraindre à des types de cartes, par exemple # project.models / User {: name "John": age 42} produira une carte déclarée comme (défrecord User ...) .

Les deux utilisations n'ont pas de relation (directe).

Dans Clojure, lorsque vous voyez le symbole # , c'est un indice géant que vous "parlez" au Clojure Reader , pas au Clojure Compiler . Consultez la documentation complète sur le Reader ici: https://clojure.org/reference/reader .

Le Reader est responsable de la conversion du texte brut d'un fichier source en une collection de structures de données. Par exemple, en comparant Clojure à Java, nous avons

(vector "Goodbye" "cruel" "world!" )

et

[ "Goodbye" "cruel" "world!" ]

De même, il existe des raccourcis que le Reader reconnaît même dans le code source de Clojure (avant que le compilateur ne le convertisse en bytecode Java), juste pour vous éviter de taper. Ces "Macros Reader" sont converties de votre code source "forme courte" en "Clojure standard" avant même que le compilateur Clojure ne démarre. Par exemple:

@my-atom                       =>   (deref my-atom)    ; not using `#`
#'map                          =>   (var map)
#{ 1 2 3 }                     =>   (hash-set 1 2 3)
#_(launch-missiles 12.3 45.6)  =>   ``                 ; i.e. "nothing"
#(+ 1 %)                       =>   (fn [x] (+ 1 x))

et ainsi de suite. Comme le montre l'opérateur @ ou deref , toutes les macros Reader n'utilisent pas le symbole # (hash / deref / octothorpe). Notez que, même dans le cas d'un littéral vectoriel:

[ "Goodbye" "cruel" "world!" ]   ; Clojure vector of 3 strings

; Java ArrayList of 3 strings
var msg = new ArrayList<String>();
msg.add( "Goodbye" );
msg.add( "cruel" );
msg.add( "world!" );

le Reader crée un résultat comme si vous aviez tapé:

; Clojure          ; Java
"Hello"      =>    new String( "Hello" )

D'autres Lisps ont des lecteurs programmables appropriés, et par conséquent lisent les macros. Clojure n'a pas vraiment de lecteur programmable - les utilisateurs ne peuvent pas facilement ajouter de nouvelles macros de lecture - mais le système Clojure utilise en interne des macros de lecture. La macro de lecture # est la macro dispatch , le caractère suivant le # étant une clé dans une table de macro de lecture ultérieure.

Alors oui, le # signifie quelque chose; mais c'est tellement profond et geek que vous n'avez pas vraiment besoin de le savoir.