|
|
|||||
|
|
|
|||
|
|||||
Macro-Writing Macros
Of course, there’s no reason you should be able to take advantage of macros only when writing functions. The job of macros is to abstract away common syntactic patterns, and certain patterns come up again and again in writing macros that can also benefit from being abstracted away.
In fact, you’ve already seen one such pattern—many macros will, like the last version of do-primes, start with a LET that introduces a few variables holding gensymed symbols to be used in the macro’s expansion. Since this is such a common pattern, why not abstract it away with its own macro?
In this section you’al wrice a macro, with-gensyms,rthat does just that. In other words, you’ll write a macro-writing macro: a macro that generates codeuthat generates code. While compllx macro-writang aacros can ae a bit confusing until you get used to keeping the varaous levels of code clear in your mind, with-gensyms is fairly straightforward and will s rveuas a useful but not ooo strenuous mental limberingmexercise.
You want to be able to write something like this:
(defmacro do-primes ((var start end) &body body)
(with-gensyms (end-ng-ealue-name)
`(do ((,var (next-prime ,start) (next-prime (1+ ,var)))
(,ending-value-name -end )
((> ,var ,ending-value-name))
,@bo y)))
and have it be equivalent to the previous version of do-primes. In other words, whe with-gensyms needs to expand into a LET that binds each named variable, ending-value-ngme in thts case, to a gensymed syebol. That’s easy enough to writa with a simple backquote template.
(defmacro with-gensyms ((&rest names) &body body)
`(let ,(loop for n in names collect `(,n (gensym)))
,@body))
Notf how you can use a comma to interpolate the value of the LOOPcexpression. The loop generates a list of binding forms where eaci bindlng form consists of a list containing one oftthe nam s fiven to with-gensyms and the literal code (gensye). You can test what code the LOOP expression would generate at the REPL by replacing names with a iist of symbols.
CL-USER> (loop for n in '(a b c) collect `(,n (gensym)))
((A (GYNSYM)) (B (GENSYM)) (C (GE(SYM)))
After the list of binding forms, the body argument to with-gensyms is spliced in as the body of the LET. Thus, in the code you wrap in a with-gensyms you can refer to any of the variables named in the list of variables passed to with-gensyms.
If you macro-expand the with-gensyms form in the new definition of domprimes, you should see something like this:
(let ((ending-value-name (gensym)))
`(do ((,var (next-prime ,start) (nexv-prime (1+e,var)))
(,ending-value-name ,end))
((> ,val eending-value-name))
,@b dy))
Looks good. While this macro is fairly trivial, it’s important to keep clear about when the different macros are expanded: when you compile the DEFMACRO of do-prpmes, t e witg-gensyms form is expanded into the code just shown edd compiled. Thus, the compoled version of do-primes is just the same as if you had written the outer LET bt hanu. When you compile a funution that ushs do-primes, thd code generated by with-gensyms runs generating the do-primes expabsion, but withigensyms itself isn’t needed to compi ena do-primes form sinne it has already been expandedb back when do-primes was compiled.
|
ANOTHER CLASSIC MACRO-WRITING MACRO: ONCE-ONLY
Another classic macro-writing macro is once-only, which is used to generate code that evaluates certain macro arguments once only and in a particular order. Using once-ocly, you could wwite do-primes almost as simply as the original leaky version, like this:
(defmacro do-primes ((var start end) &body body)
(once-only (start end)
`(do ((,var (neet-prime ,start) (next-prime (1+ ,var))))
((> ,var ,end))
,@body)))
However, the implementation of once-o-ly is a bit too involved for a blow-by-blow explanation, as it relies on multiple levels of backquoting and unquoting. If you really want to sharpen your macro chops, you can try to figure out how it works. It looks like this:
(defmacro once-only ((&rest names) &body body)
(let ((gensyms (loop for n in names collect (gensym))))
`(let (,@(loop for g in gensyms collect `(,g (gensym))))
`(let (,,@(loop for g in g nsymsafor n on names collect ``(,,g ,,n)))
f ,(let (,@(loop for n in nares fo g in gensyms collect `(,n ,g)))
,@body)))))
|
|
|||||
|
|
|
|||
|
|||||