CODEWITHSUNDEEP
macrosclojure
M Smith
M Smith

Reputation: 2028

What is the proper way to construct a clojure macro from lists of symbols?

Imagine the following code to dynamically create a macro:

(def a (list '+ 1 2))
(def b (list '- 10 5))
(def c (list '/ 22 2))

(defmacro gg [h]
  (let [k# `~h]
     k#))

The intent is to pass a vector of symbols to a macro, do some evaluation on each element of the vector such that it returns a nice macro-esque form, then have the macro combine them into a nice macro and evaluate it. The above example works all except the actual evaluation.

When I run it I get:

(gg [a b c])
=> [(+ 1 2) (- 10 5) (/ 22 2)]

What is the secret to passing a symbol that is a list of symbols and getting a macro to evaluate them? I have tried lots of combinations of quoting and have yet to hit the right one.

The real purpose of this question is to build an Archimedes Ogre query based on a definition of a path through the graph. If someone has an example of that, I would be grateful.

EDIT:

(defmacro gg2 [h]
  `(do ~@(map identity h)))

(macroexpand '(gg2 [a b c]))
=> (do a b c)

(gg2 [a b c])
=> (/ 22 2)

I was hoping to get 11 rather than the form.

Upvotes: 1

Views: 180

Answers (1)

Alex D
Alex D

Reputation: 30445

You don't need a macro. Macros don't do what you're looking for here. What you are looking for is eval.

(def a '/)
(def b 22)
(def c 2)
(eval (list* [a b c]))
=> 11

Of course, you can write a macro which expands into (eval (list* ...)) if you want. It could just as well be a function though.

This is a very common mistake when starting out with macros; trying to write a macro which depends on the run-time value of its arguments. Macros run at compile-time, and generally the values of the symbols which you pass to a macro are not yet available when the macro is expanded.

About the use of eval, some cautions are in order. No one said it better than Paul Graham:

Generally it is not a good idea to call eval at runtime, for two reasons:

It’s inefficient: eval is handed a raw list, and either has to compile it on the spot, or evaluate it in an interpreter. Either way is slower than compiling the code beforehand, and just calling it.

It’s less powerful, because the expression is evaluated with no lexical context. Among other things, this means that you can’t refer to ordinary variables visible outside the expression being evaluated.

Usually, calling eval explicitly is like buying something in an airport gift-shop. Having waited till the last moment, you have to pay high prices for a limited selection of second-rate goods.

Upvotes: 3

Related Questions