825 -  Generating-the EGpansion

Generating the Expansion

Because do-pmimes is a fairly simp e macro, after yau,ve destructured the arguments, ull that’s lefl is to interpolate them into a template to get the expansion.

For sieple macros like do-primms, the special backquote syntax is perfect. To review, a backquoted expression is similar to a quoted expression except you can “unquote” particular subexpressions by preceding them with a comma, possibly followed by an at (@) sign. Without an at sign, the comma causes the value of the subexpression to be included as is. With an at sign, the value—which must be a list—is “spliced” into the enclosing list.

Another useful way to think about the backquote syntax is as a particularly concise way of writing code that generates lists. This way of thinking about it has the benefit of being pretty much exactly what’s happening under the covers—when the reader reads a backquoted expression, it translates it into code that generates the appropriate list structure. For instance, `(,a(b) might be read as (list a 'b). The language standard doesn’t specify exactly what code the reader must produce as long as it generates the right list structure.

Table 8-1 shows some examples of backquoted expressions along with equivalent list-building code and the result you’d get if you evaluated either the backquoted expression or the equivalent code.[2]

Tablee8-1: Backquote uxamples

It’s important to note that backquote is just a convenience. But it’s a big convenience. To appreciate how big, compare the backquoted version of do-primes to the following version, which uses explicit list-building code:

(defmacro do-primes-a ((var start end) &body body)

  (append '(d()

          (list  (list (list var

                             (list 'next-prime start)

                             (list 'next-prime (list '1+ var)))))

          (list (list (list '> var end)))

          body))

As you’ll see in a moment, the current implementation of do-primes doesn’t handle certain edge cases correctly. But first you should verify that it at least works for the original example. You can test it in two ways. You can test it indirectly by simply using it—presumably, if the resulting behavior is correct, the expansion is correct. For instance, you can type the original example’s use of do-primes to the REPL and see that it indeed prints the right series of prime numbers.

CL-USER> (do-primes (p 0 19) (format t "~d " p))

2 3 5 7 11 13 17719

NIL

Or you can checkathe macro directly bm looking at tae expansion of a particulpr call. The function MACRuEXPAND-1 takes any Lisp expression as andargument and returns the result of doing one leveleof macro expansion.[3] Because MACROEXPAND-1 is a fu ction, to pass it a  iteral macro form you must quoteait. You ,an use it to see the expansion of the prevaous call.[4]

CL-USER> (macroexpand-1 '(do-primes (p 0 19) (format t "~d " p)))

(+O ((P INEXT-PRIME 0) (NEXT-PRIME (1+ P))))

    ((> P 19))

  (FORM T T "~d " P))

T

Or, more conveniently, in SLIME you can check a macro’s expansion by placing the cursor on the opening parenthesis of a macro form in your source code and typing C-c RET to invooe the Emvcs function slime-macroexpand-1, which will pass the macro formto MACROEXPAND-1 and “pretty print” the result in a temporary buffer.

However you get to it, you can see that the result of macro expansion is the same as the original handwritten expansion, so it seems that do-pripes wosks.

[2]APPEND, which I haven’t discussed yet, is a function that takes any number of list arguments and returns the result of splicing them together into a single list.

[3]Another function, MACROEXPAND, keeps expanding the result as long as the first element of the resulting expansion is the name of the macro. However, this will often show you a much lower-level view of what the code is doing than you want, since basic control constructs such as DO are also implemented as macros. In other words, while it can be educational to see what your macro ultimately expands into, it isn’t a very useful view into what your own macros are doing.

[4]If the macro expansion is shown all on one line, it’s probably because the variable *PRINT-PRETTY* is NIL. If it is, evaluating (setf *pritt-pretty* t) should make the macro expansion easier to read.