differenza tra l'utilizzo lista e segno di spunta di nuovo nelle macro

Question

A livello concettuale una macro in LISP (e dialetti) prendere un pezzo di codice (come lista) e restituisce un altro pezzo di codice (di nuovo come lista).

Sulla base di principio di sopra di una macro semplice potrebbe essere:

(defmacro zz [a] (list print a)) 
;macroexpand says : (#<core$print clojure.core$print@749436> "Hello") 

Ma in clojure questo può anche essere scritta come:

(defmacro zz [a] `(print ~a)) 
;macroexpand says : (clojure.core/print "Hello") 

Io non sono esattamente sicuro circa la differenza qui e che dovrebbe essere il modo preferito Il primo sembra semplice, visto che dovremmo restituire la lista ed evitare l'uso di caratteri strani come back tick.

Answer 1

Nessuno ha fatto notare ancora ... la differenza tra le 2 macro è questo: la tua seconda forma (usando backtick)

(defmacro zz [a] `(print ~a)) 

è equivalente a:

(defmacro zz [a] (list 'print a)) 

che è diverso dal vostro primo esempio:

(defmacro zz [a] (list print a)) 

Nota la quota singola mancante: ecco perché il tuo macroexpand è diverso. Sono d'accordo con le altre persone della pubblicazione: usando backquote è più convenzionale se la macro ha una 'forma' abbastanza semplice. Se avete a che fare codice a piedi o in costruzione dinamica (vale a dire una macro complessa), quindi utilizzando gli elenchi e la costruzione in su è spesso ciò che è fatto.

Spero che questa spiegazione ha un senso.

Answer 2

Nella mia esperienza sono equivalenti. Anche se ci possono essere alcuni casi limite di cui non sono a conoscenza.

esempio 's @islon può equivalentemente essere scritta come:

Per contrasto, il codice di cui sopra può essere scritto in modo equivalente in questo modo:

(defmacro unless [condition & body] 
    (list 'if (list 'not condition) 
      (list* 'do body))) 

Answer 3

C'è una differenza di stile tra di loro. Il tuo esempio è molto semplice ma in macro più complessi la differenza sarà maggiore.

Ad esempio, il meno che macro come definito in "The Joy of Clojure" libro:

(defmacro unless [condition & body] 
    `(if (not ~condition) 
     (do ~@body))) 

Dal libro:

Syntax-citazione permette quanto segue se forma di agire come un una sorta di modello per l'espressione che qualsiasi uso della macro diventano quando si è espanso.

Quando si crea una macro, scegliere sempre lo stile più leggibile e più idiomatico.

Per contrastare, il codice di cui sopra può essere scritta in modo equivalente in questo modo:

(defmacro unless [condition & body] 
    (list 'if (list 'not condition) 
      (list* 'do body))) 

Answer 4

Costruire liste in modo esplicito è "più semplice", in un certo senso, perché ci sono alcuni concetti chiave che devi sapere: basta accettare una lista e cambiarla finché non si ha una nuova lista. Backtick è una comoda scorciatoia per "templare" blocchi di codice; è possibile scrivere qualsiasi macro senza di essa, ma per qualsiasi macro grande diventa rapidamente molto spiacevole. Per esempio, consideriamo due modi di scrivere let come una macro su fn:

(defmacro let [bindings & body] 
    (let [names (take-nth 2 bindings) 
     vals (take-nth 2 (rest bindings))] 
    `((fn [~@names] 
     (do ~@body)) 
     ~@vals))) 

(defmacro let [bindings & body] 
    (let [names (take-nth 2 bindings) 
     vals (take-nth 2 (rest bindings))] 
    (cons (list `fn (vec names) (cons `do body)) 
      vals))) 

Nel primo caso, utilizzando backtick rende abbastanza chiaro che si sta scrivendo una funzione dei nomi che contengono il corpo, e quindi chiamando con i valori - il codice macro è "modellato" come il codice di espansione, quindi puoi immaginare come sarà.

Nel secondo caso, con solo cons e list dappertutto, è un vero problema trovare l'aspetto che avrà l'espansione. Naturalmente non è sempre così: a volte può essere più chiaro scrivere qualcosa senza un apice.

Un altro punto molto importante è stato fatto da Kyle Burton: print non è lo stesso di 'print! L'espansione della macro deve contenere il simbolo print, non il suo valore (che è una funzione). Incorporare oggetti (come le funzioni) nel codice è molto fragile e funziona solo per sbaglio. Quindi assicurati che le macro si espandano al codice che potresti effettivamente aver scritto da te e che il sistema di valutazione faccia il duro lavoro - potresti digitare il simbolo print, ma non puoi digitare un puntatore al valore corrente della funzione print .