Using macroexpand-1 to expand macros within let forms (Practical Common Lisp, Chapter 8, "Plugging the Leaks")

Question

In Chapter 8 of Practical Common Lisp, "Plugging the leaks" we define this macro and discover that it leaks through examination with macroexpand-1

(defmacro do-primes ((var start end) &body body)
  `(do ((,var (next-prime ,start) (next-prime (1+ ,var)))
        (ending-value ,end))
       ((> ,var ending-value))
     ,@body))

The following seemingly innocent call to do-primes doesn't work correctly because of this leak:

(do-primes (ending-value 0 10) (print ending-value)) Neither does this one:

(let ((ending-value 0)) (do-primes (p 0 10) (incf ending-value p)) ending-value)

I can use macroexpand-1 on that like so where I've named this macro do-primes4

(macroexpand-1 '(do-primes4 (ending-value 0 10)
  (print ending-value)))

(DO ((ENDING-VALUE (NEXT-PRIME 0) (NEXT-PRIME (1+ ENDING-VALUE)))
     (ENDING-VALUE 10))
    ((> ENDING-VALUE ENDING-VALUE))
  (PRINT ENDING-VALUE))

However I can't do the same on the second form where the macro call is with the let

(macroexpand-1 '(let ((ending-value 0))
  (do-primes4 (p 0 10)
    (incf ending-value p))
  ending-value))

(LET ((ENDING-VALUE 0))
  (DO-PRIMES4 (P 0 10)
    (INCF ENDING-VALUE P))
  ENDING-VALUE)

It seems not to actually macro-expand do-primes4. I am using SBCL.

Answer 1

Although, as Rainer Joswig pointed out, you need a code-walker to see what the expansion actually is in this case, and neither macroexpand-1 more macroexpand are code walkers, you don't actually need that to see what the problem is here. In a form like

(let ((ending-value 0))
  (do-primes (p 0 10)
    (incf ending-value p))
  ending-value)

You can just expand the do-primes form at top-level and then substitute it in, to get the obvious thing:

(let ((ending-value 0))
  (do ((p (next-prime 0) (next-prime (1+ p))) (ending-value 10))
      ((> p ending-value))
    (incf ending-value p))
  ending-value)

And now it's immediately apparent what the problem is: the ending-value you are incrementing is not the binding you think it is.

There are various CL code-walkers out there: I'm not familiar enough with them to recommend one.

Answer 2

GNU Emacs / SLIME

use c-c m-m on the form. It invokes the code walker. Result:

(LET ((ENDING-VALUE 0))
  (BLOCK NIL
    (LET ((P (NEXT-PRIME 0)) (ENDING-VALUE 10))
      (DECLARE (IGNORABLE P ENDING-VALUE))
      (TAGBODY
    (GO #:G586)
       #:G585
    (TAGBODY (SETQ ENDING-VALUE (+ P ENDING-VALUE)))
    (PROGN (SETQ P (NEXT-PRIME (1+ P))) NIL)
       #:G586
    (IF (> P ENDING-VALUE)
            NIL
            (GO #:G585))
    (RETURN-FROM NIL (PROGN)))))
  ENDING-VALUE)

Answer 3

There are two macro-expansion functions, macroexpand and macroexpand-1, http://clhs.lisp.se/Body/f_mexp_.htm. Both expand macros, macroexpand-1 does one level, macroexpand keeps going until it is completely expanded. Both return two values:

1. The expansion
2. A flag which indicates that an expansion occurred

The macro expansion is this:

; macro expansion

(macroexpand-1 '(do-primes4 (ending-value 0 10)
   (print ending-value)))
(DO ((ENDING-VALUE (NEXT-PRIME 0) (NEXT-PRIME (1+ ENDING-VALUE)))
     (ENDING-VALUE 10))
((> ENDING-VALUE ENDING-VALUE))
  (PRINT ENDING-VALUE))

; flag
T

The expansion is printed first, and then the flag - here T to show that an expansion occurred.

The problem with your second example is that the let is the first item in the macro-expansion. At the moment you are only attempting to expand the let form, with its body returned unchanged:

(macroexpand-1 '(let ((ending-value 0)) (do-primes4 (ending-value 0 10)
                                               (print ending-value))))

(LET ((ENDING-VALUE 0))
   (DO-PRIMES4 (ENDING-VALUE 0 10)
      (PRINT ENDING-VALUE)))
NIL

The flag takes the value NIL, to show that no expansion occurred.

The let form expands to itself, because it isn't a macro, with flag NIL:

CL-USER> (macroexpand-1 '(let ((x 0))))
  (LET ((X 0)))
  NIL