如何编写 Clojure 宏来获取 var 的值？

Question

user=> (def v-1 "this is v1")
user=> (def v-2 "this is v2")
user=> (defmacro m [v] (symbol (str "v-" v)))
user=> (m 1)
"this is v1"
user=> (m 2)
"this is v2"
user=> (let [i 2] (m i))
CompilerException java.lang.RuntimeException: Unable to resolve symbol: v-i in this context, compiling:(NO_SOURCE_PATH:73:12)

Can I write a macro let both

(m 2)

and

(let [i 2] (mi))

get "this is v2" ?

Answer 1

This is possible without a macro:

(defn m [v] (var-get (resolve (symbol (str "v-" v)))))

(m 1) ;; => "This is v1"
(let [i 2] (m i)) ;; => "This is v2"

You can use a macro too if you want:

(defmacro m [v] `@(resolve (symbol (str "v-" ~v))))

Answer 2

A plain function seems much more likely to be what you want.

First, though, to address the original question, if you wanted to insist on using a macro, macros are regular functions that happen to be called at compile time, so you can look up a Var using its symbolic name and obtain its value using deref just like you could at (your application's, as opposed to your macro's) runtime:

(defmacro var-value [vsym] @(resolve vsym))

(def foo 1)

(var-value foo)
;= 1
(macroexpand-1 '(var-value foo))
;= 1

Note that the above 1 is the actual macroexpansion here. This is different to

(defmacro var-value [vsym] `@(resolve ~vsym))

in that the latter expands to a call to resolve , and so the lookup given that implementation is postponed to your app's runtime.

(macroexpand-1 '(var-value foo))
;= (clojure.core/deref (clojure.core/resolve foo))

So this code will just be inlined wherever you call the macro.

Of course the macro could also expand to a symbol – eg

(defmacro prefixed-var [suffix]
  `(symbol (str "v-" ssuffix)))

will produce expansions like v-1 (for (prefixed-var 1) ) etc.

Going back to the subject of the suitability of macros here, however, if you use a macro, all the information that you need to produce your expansion must be available at compile time, and so in general you cannot use the values of let / loop locals or function arguments in your expansion for the fundamental reason that they don't have any fixed value at compile time. ¹

Thus the cleanest approach would probably be to wrap a resolve call in defn and call the resulting function – although of course to know for sure, we'd need to know what problem you were trying to solve by introducing a macro that performs a Var lookup.

---

¹ Except if statically assigned constant values, as in the example given in the question text; I'm assuming you're thinking of using runtime values of locals in general, not just those that whose initialization expressions are constant literals.