Dynamic symbols in Clojure Macro/Special Form

Question

I have a question regarding how to define functions/macros which call other macros or special forms but where one of the symbols passed in needs to be dynamic.

The simplest version of this question is described below:

We can define variables using def

(def x 0)

But what if we wanted the name x to be determined programmatically so that we could do the equivalent of?

(let [a 'b]
  (our-def a 3)) => user/b

We could try to define a function

(defn defn2 [sym val]
  (def sym val))

However it does not do what we want

(def2 'y 1)   => #'user/sym

At first it seems like a macro works (even though it seems like it would be unnecessary)

(defmacro def3 [sym val]
  `(def ~sym ~val))

(def3 z 2) => user/z

but it is just superficial, because we're really right back where we started with regular def.

(let [a 'b]
  (def3 a 3)) => user/a

I can do it if I use eval, but it doesn't seem like eval should be necessary

(defn def4 [sym val]
  (eval `(def ~sym ~val)))

(let [a 'b]
  (def4 a 4)) => user/b

If there are other built-in commands that could achieve this particular example, they are not really what I am looking for since def is just to show a particular example. There are macros more complicated than def that I might want to call and not have to worry about how they were internally implemented.

Answer 1

First: The right way to do this is to use macro that starts with def... since this is the way people have been doing defs and is of little surprise to the user.

To answer you question: Use intern:

(def foo 'bar)
(intern *ns* foo :hi)
(pr bar) ;; => :hi
(intern *ns* foo :hi2)
(pr bar) ;; => :hi2

If you want to use macros do this:

(def z 'aa)
(defmacro def3 [sym val]
  `(def ~(eval sym) ~val))
(def3 z 2)
(pr aa) ;; => 2