Clojure-diferencia entre ''(apóstrofe) y `(contracción)

read-eval-print-loop apostrophe

Question

Soy bastante nuevo en Clojure y no estoy seguro de entender completamente la diferencia entre apóstrofe y contracción en Clojure.

(def x 5)

;; Question 1
(+ x x)  ;; evaluates to 10
''(+ x x) ;; evaluates to (+ x x)
`(+ x x) ;; evaluates to (clojure.core/+ user/x user/x)

;; Question 2
`(~+ ~x ~x) ;; evaluates to (#<core$_PLUS_ clojure.core$_PLUS_@32ee28a9> 5 5)

1. Corríjame si me equivoco, pero me parece que el apóstrofe evita que todos los símbolos (es decir, + y x) se resuelvan en sus respectivas var, mientras que el backtick permite que los símbolos se resuelvan a sus var (pero no evalúa los valores) dentro de la var). ¿Es esto correcto?
2. ¿Qué hace exactamente el símbolo entre comillas (~) aquí? ¿Se está evaluando la var a su valor real (es decir, el símbolo + al objeto de función y el símbolo x al objeto numérico)? Si pudiera explicar esto en términos de las fases READ-COMPILE-EVAL de Clojure, eso también sería útil.

Answer 1

Backquote es una sintaxis-cita en términos de Clojure, consulte su descripción en http://clojure.org/reader .

Durante la lectura, `(~ + ~ x ~ x) se expande para formar una lista que genere referencias al entorno léxico. Entonces el compilador compila este código. Veamos a qué se expande `(~ + ~ x ~ x), anteponiéndolo con una cita:

user=> ''`(~+ ~x ~x)
(clojure.core/seq (clojure.core/concat (clojure.core/list +) (clojure.core/list x) (clojure.core/list x)))

Si solo inserta este formulario en el editor de texto en lugar de `(~ + ~ x ~ x), generará una lista con la función + y dos x. Por lo tanto, `(~ + ~ x ~ x) se expande a código de Clojure que genera una lista de estructura particular.

Backquote es un tipo de lenguaje de plantilla para datos de Clojure (listas, arreglos, etc.).

Answer 2

Cuando cite una colección con '' , el nombre del símbolo será citado exactamente como lo ingresó.

''(+ x x) 
=> (+ x x)
(map namespace *1)
=> (nil nil nil)
''(bingo/+ lara/y user/z)
=> (bingo/+ lara/y user/z)
(map namespace *1)
=> ("bingo" "lara" "user")

Cuando cita una colección con la marca invertida, intenta encontrar el espacio de nombres de cada símbolo. Si no puede encontrar uno, usa el espacio de nombres actual. Si especifica un espacio de nombres, funciona igual que '' con un espacio de nombres calificado.

`(+ x x)
= > (clojure.core/+ user/x user/x)
(map namespace *1)
=> ("clojure.core" "user" "user")

Cuando esté utilizando ~ interior ` el formulario simplemente no tendrá comillas. Esto es útil para crear macros en las que la macro usa símbolos del espacio de nombres en el que se define, así como símbolos del espacio de nombres donde se usa.

 `(+ ~''x x)
 => (clojure.core/+ x user/x)
 `(+ ~x x)
 => (clojure.core/+ 3 user/x)

Finalmente, puedes quitar una cita de toda una colección de empalmes de cosas entre comillas.

 `(+ ~@`(x x))
 => (clojure.core/+ user/x user/x)

Ver ambos xes podrían haberse pasado como una lista de símbolos calificados para el espacio de nombres y se habrían empalmado en otra lista. No puede utilizar ~ o ~@ fuera de una colección entre comillas de comillas invertidas.