How to establish a variable binding that will be active during macroexpansion time?

Question

Let's define a function, the body of which contains the macro, which will be expanded at some unspecified time and will use a global dynamic value of *test* during this process.

> (defvar *test* nil)
> (defmacro body ()
    `(print ,*test*))
> (defun test ()
    (body))
> (test)
NIL

But what if I want to bind *test* to, say, 1 during function definition, so that the macroexpansion operated with this binding in effect and the call to test produced 1 instead of NIL.

Just wrapping defun in let doesn't work:

> (let ((*test* 1))
    (defun test ()
      (body)))
> (test)
NIL

Probably, it is related to this line in Hyperspec:

defun is not required to perform any compile-time side effects

But are there any other ways to do that?

I've made up this trivial example to single out the problem. But my use-case is more complicated with some parts generated separately, so, basically, I can't do that inside the macro. — Vsevolod Dyomkin, Jan 04 '12 at 15:18
Just remove the , before * test * in the macro, so that the value of * test * is evaluated at run-time, and not compile time. Although this may defeat the purpose of what you're trying to do? — Clayton Stanley, Jan 05 '12 at 16:33

score 3 · Accepted Answer · answered Jan 04 '12 at 16:16

As you yourself write, macro are expanded at unspecified time. In my SBCL the macro is expanded before the whole form is evaluated, which means before the LET binding is in effect. For some interpreters the macro might be expanded when the function is executed, after the binding expired.

Early versions of what became Common Lisp included such mechanism through COMPILER-LET, but it has been removed. See COMPILER-LET-CONFUSION issue for more detail. Lexically some of the effects can be achieved using MACROLET/SYMBOL-MACROLET. Dynamically it is difficult to make this work sanely and I would recommend rethinking the approach, if using actual dynamic bindings seem necessary.

score 1 · Answer 2 · answered Jan 04 '12 at 17:02

You could introduce a let like this:

(defvar *test* nil)

(defmacro foo ()
  (let ((test (gensym)))
    `(let ((,test *test*))
       (print ,test))))

(defun test-foo ()
  (foo))

(test-foo) => print and returns NIL
(let ((*test* 1))
  (test-foo)) => print and returns 1

score 1 · Answer 3 · answered Jan 04 '12 at 21:08

What about controlling the time of evaluation by using a macro instead of let (here it is assigning a known value to a known variable, but it could easily be expanded to handle more variables since we're playing with dynamic variables):

(defmacro letter (&body body)
  (let ((old-test *test*))
    (set '*test* 1)
    `(progn
       ,@body
       (set '*test* ,old-test))))

Defining test:

(letter (defun test () (body)))

Using test:

CL-USER> (test)

1 
1

This seems to work as expected on SBCL, need to get some sleep before trying it on other implementations.

Hmmm, macro-expanding makes it obvious that letter works correctly only when macro-expanded AND EVALed. Simply macro-expanding doesn't restore *test* to its old value (doh). So it's not a good 'binding emulator'.

score 0 · Answer 4 · answered Jan 04 '12 at 14:21

0

I think it because *test* variable is valid within the body of the let.

answered Jan 04 '12 at 14:21

Tyrus

23
3

How to establish a variable binding that will be active during macroexpansion time?

4 Answers4