Come faccio a rendere questa macro variadic in clojure?

Question

Voglio fare qualcosa chiamato ds in modo che

(let [a 2] 
    (ds a)) 

->

"a->2" 

e

(let [a 1 b 2 c 3] 
    (ds a b c)) 

->

"a->1, b->2, c->3" 

E finora ho ottenuto come quanto:

(defmacro ds3 [a b c] 
    `(clojure.string/join ", " 
      [(str '~a "->" ~a) 
      (str '~b "->" ~b) 
      (str '~c "->" ~c)])) 

che sembra funzionare:

(let [ a 1 b 2 c 3] 
    (ds3 a b c)) ; "1->1, 2->2, 3->3" 

Ovviamente posso definire DS1 DS2 DS3 ecc ..., ma mi chiedevo come farlo variadic?

Answer 1

Qui si va: risposta

(defmacro ds [& symbols]                                
    `(clojure.string/join ", "                               
         ~(into [] 
          (map (fn [s] `(str ~(name s) "->" ~s)) symbols))))                 

Answer 2

di Ankur è probabilmente il più pratico, ma è rinviare un sacco di lavoro a tempo di esecuzione, che potrebbe essere fatto al momento macroexpansion. E 'un esercizio utile, e una bella dimostrazione delle macro di potenza può portare, per vedere come gran parte del lavoro che si può fare al momento della compilazione:

(defmacro ds [& args] 
    `(str ~(str (name (first args)) "->") 
     ~(first args) 
     ~@(for [arg (rest args) 
       clause [(str ", " (name arg) "->") arg]] 
      clause))) 

(macroexpand-1 '(ds a b c)) 
=> (clojure.core/str "a->" a ", b->" b ", c->" c) 

questo modo si evita la costruzione di tutti gli oggetti temporanei in fase di esecuzione, e fa l'assoluto numero minimo di concatenazioni di stringhe.

Answer 3

EDIT:

grazie ai suggerimenti di @amalloy, qui ci sono alcune macro migliorate che non utilizzano il 'male male' eval e comprendono alcuni mini-test:

(import 'java.lang.ArithmeticException) 

(defmacro explain-expr 
    "Produce a string representation of the unevaluated expression x, concatenated to 
    an arrow and a string representation of the result of evaluating x, including 
    Exceptions should they arise." 
    [x] 
    `(str ~(str x) " ~~> " 
     (try ~x (catch Exception e# (str e#))))) 

(println (explain-expr (* 42 42))) 
(println (explain-expr (let [x 1] x))) 
(println (explain-expr (/ 6 0))) 
(println (let [x 1] (explain-expr x))) 
(let [y 37] (println (explain-expr (let [x 19] (* x y))))) 
(let [y 37] (println (explain-expr (let [y 19] (* y y))))) 

(* 42 42) ~~> 1764 
(let [x 1] x) ~~> 1 
(/ 6 0) ~~> java.lang.ArithmeticException: Divide by zero 
x ~~> 1 
(let [x 19] (* x y)) ~~> 703 
(let [y 19] (* y y)) ~~> 361 

(defmacro explain-exprs 
    "Produce string representations of the unevaluated expressions xs, concatenated 
    to arrows and string representations of the results of evaluating each 
    expression, including Exceptions should they arise." 
    [& xs] 
    (into [] (map (fn [x] 
        `(str ~(str x) " ~~> " 
         (try ~x (catch Exception e# (str e#))))) 
       xs))) 

(clojure.pprint/pprint 
(let [y 37] 
    (explain-exprs 
    (* 42 42) 
    (let [x 19] (* x y)) 
    (let [y 19] (* y y)) 
    (* y y) 
    (/ 6 0)))) 

["(* 42 42) ~~> 1764" 
"(let [x 19] (* x y)) ~~> 703" 
"(let [y 19] (* y y)) ~~> 361" 
"(* y y) ~~> 1369" 
"(/ 6 0) ~~> java.lang.ArithmeticException: Divide by zero"] 

(defmacro explanation-map 
    "Produce a hashmap from string representations of the unevaluated expressions 
    exprs to the results of evaluating each expression in exprs, including 
    Exceptions should they arise." 
    [& exprs] 
    (into {} 
     (map (fn [expr] 
       `[~(str expr) 
       (try ~expr (catch Exception e# (str e#)))]) 
      exprs))) 

(clojure.pprint/pprint 
(let [y 37] 
    (explanation-map 
    (* 42 42) 
    (let [x 19] (* x y)) 
    (let [y 19] (* y y)) 
    (* y y) 
    (/ 6 0)))) 

{"(* 42 42)" 1764, 
"(let [x 19] (* x y))" 703, 
"(let [y 19] (* y y))" 361, 
"(* y y)" 1369, 
"(/ 6 0)" "java.lang.ArithmeticException: Divide by zero"} 

DISAPPROVATO:

che sto lasciando questo come un esempio di ciò che non da fare.

Ecco una variante che funziona su qualsiasi tipo di espressione (credo)

(defmacro dump-strings-and-values 
    "Produces parallel vectors of printable dump strings and values. A dump string 
    shows an expression, unevaluated, then a funny arrow, then the value of the 
    expression." 
    [& xs] 
    `(apply map vector ;; transpose 
      (for [x# '~xs 
       v# [(try (eval x#) (catch Exception e# (str e#)))]] 
      [(str x# " ~~> " v#) v#]))) 

(defmacro pdump 
    "Print dump strings for one or more given expressions by side effect; return 
    the value of the last actual argument." 
    [& xs] 
    `(let [[ss# vs#] 
     (dump-strings-and-values ~@xs)] 
    (clojure.pprint/pprint ss#) 
    (last vs#)) 

Alcuni esempi:

(pdump (* 6 7)) 

stampe ["(* 6 7) ~~> 42"] e restituisce 42.

(pdump (* 7 6) (/ 1 0) (into {} [[:a 1]])) 

stampe

["(* 7 6) ~~> 42" 
"(/ 1 0) ~~> java.lang.ArithmeticException: Divide by zero" 
"(into {} [[:a 1]]) ~~> {:a 1}"] 

e restituisce {:a 1}.

EDIT:

Il mio tentativo di sbarazzarsi delle staffe esterne nell'output stampato, vale a dire

(defmacro vdump 
    "Print dump strings for one or more given expressions by side effect; return 
    the value of the last actual argument." 
    [& xs] 
    `(let [[ss# vs#] 
     (dump-strings-and-values ~@xs)] 
    (map clojure.pprint/pprint ss#) 
    (last vs#))) 

fa NON lavoro, e io non sono sicuro perché. Non stampa l'output, ma l'espansione della macro sembra buona. Potrebbe essere un problema nREPL o REPL, ma ho ceduto e ho appena utilizzato quello sopra e non mi preoccupo molto delle parentesi.