2 @c This is part of the SXEmacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
4 @c Copyright (C) 2005 Sebastian Freundt <hroptatyr@sxemacs.org>
5 @c See the file lispref.texi for copying conditions.
6 @setfilename ../../info/macros.info
8 @node Macros, Loading, Functions and Commands, Top
12 @dfn{Macros} enable you to define new control constructs and other
13 language features. A macro is defined much like a function, but instead
14 of telling how to compute a value, it tells how to compute another Lisp
15 expression which will in turn compute the value. We call this
16 expression the @dfn{expansion} of the macro.
18 Macros can do this because they operate on the unevaluated expressions
19 for the arguments, not on the argument values as functions do. They can
20 therefore construct an expansion containing these argument expressions
23 If you are using a macro to do something an ordinary function could
24 do, just for the sake of speed, consider using an inline function
25 instead. @xref{Inline Functions}.
28 * Simple Macro:: A basic example.
29 * Expansion:: How, when and why macros are expanded.
30 * Compiling Macros:: How macros are expanded by the compiler.
31 * Defining Macros:: How to write a macro definition.
32 * Backquote:: Easier construction of list structure.
33 * Problems with Macros:: Don't evaluate the macro arguments too many times.
34 Don't hide the user's variables.
39 @section A Simple Example of a Macro
41 Suppose we would like to define a Lisp construct to increment a
42 variable value, much like the @code{++} operator in C. We would like to
43 write @code{(inc x)} and have the effect of @code{(setq x (1+ x))}.
44 Here's a macro definition that does the job:
50 (list 'setq var (list '1+ var)))
54 When this is called with @code{(inc x)}, the argument @code{var} has
55 the value @code{x}---@emph{not} the @emph{value} of @code{x}. The body
56 of the macro uses this to construct the expansion, which is @code{(setq
57 x (1+ x))}. Once the macro definition returns this expansion, Lisp
58 proceeds to evaluate it, thus incrementing @code{x}.
62 @section Expansion of a Macro Call
63 @cindex expansion of macros
66 A macro call looks just like a function call in that it is a list which
67 starts with the name of the macro. The rest of the elements of the list
68 are the arguments of the macro.
70 Evaluation of the macro call begins like evaluation of a function call
71 except for one crucial difference: the macro arguments are the actual
72 expressions appearing in the macro call. They are not evaluated before
73 they are given to the macro definition. By contrast, the arguments of a
74 function are results of evaluating the elements of the function call
77 Having obtained the arguments, Lisp invokes the macro definition just
78 as a function is invoked. The argument variables of the macro are bound
79 to the argument values from the macro call, or to a list of them in the
80 case of a @code{&rest} argument. And the macro body executes and
81 returns its value just as a function body does.
83 The second crucial difference between macros and functions is that the
84 value returned by the macro body is not the value of the macro call.
85 Instead, it is an alternate expression for computing that value, also
86 known as the @dfn{expansion} of the macro. The Lisp interpreter
87 proceeds to evaluate the expansion as soon as it comes back from the
90 Since the expansion is evaluated in the normal manner, it may contain
91 calls to other macros. It may even be a call to the same macro, though
94 You can see the expansion of a given macro call by calling
97 @defun macroexpand form &optional environment
98 @cindex macro expansion
99 This function expands @var{form}, if it is a macro call. If the result
100 is another macro call, it is expanded in turn, until something which is
101 not a macro call results. That is the value returned by
102 @code{macroexpand}. If @var{form} is not a macro call to begin with, it
103 is returned as given.
105 Note that @code{macroexpand} does not look at the subexpressions of
106 @var{form} (although some macro definitions may do so). Even if they
107 are macro calls themselves, @code{macroexpand} does not expand them.
109 The function @code{macroexpand} does not expand calls to inline functions.
110 Normally there is no need for that, since a call to an inline function is
111 no harder to understand than a call to an ordinary function.
113 If @var{environment} is provided, it specifies an alist of macro
114 definitions that shadow the currently defined macros. Byte compilation
120 (list 'setq var (list '1+ var)))
125 (macroexpand '(inc r))
126 @result{} (setq r (1+ r))
130 (defmacro inc2 (var1 var2)
131 (list 'progn (list 'inc var1) (list 'inc var2)))
136 (macroexpand '(inc2 r s))
137 @result{} (progn (inc r) (inc s)) ; @r{@code{inc} not expanded here.}
143 @node Compiling Macros
144 @section Macros and Byte Compilation
145 @cindex byte-compiling macros
147 You might ask why we take the trouble to compute an expansion for a
148 macro and then evaluate the expansion. Why not have the macro body
149 produce the desired results directly? The reason has to do with
152 When a macro call appears in a Lisp program being compiled, the Lisp
153 compiler calls the macro definition just as the interpreter would, and
154 receives an expansion. But instead of evaluating this expansion, it
155 compiles the expansion as if it had appeared directly in the program.
156 As a result, the compiled code produces the value and side effects
157 intended for the macro, but executes at full compiled speed. This would
158 not work if the macro body computed the value and side effects
159 itself---they would be computed at compile time, which is not useful.
161 In order for compilation of macro calls to work, the macros must be
162 defined in Lisp when the calls to them are compiled. The compiler has a
163 special feature to help you do this: if a file being compiled contains a
164 @code{defmacro} form, the macro is defined temporarily for the rest of
165 the compilation of that file. To use this feature, you must define the
166 macro in the same file where it is used and before its first use.
168 Byte-compiling a file executes any @code{require} calls at top-level
169 in the file. This is in case the file needs the required packages for
170 proper compilation. One way to ensure that necessary macro definitions
171 are available during compilation is to require the files that define
172 them (@pxref{Named Features}). To avoid loading the macro definition files
173 when someone @emph{runs} the compiled program, write
174 @code{eval-when-compile} around the @code{require} calls (@pxref{Eval
178 @node Defining Macros
179 @section Defining Macros
181 A Lisp macro is a list whose @sc{car} is @code{macro}. Its @sc{cdr} should
182 be a function; expansion of the macro works by applying the function
183 (with @code{apply}) to the list of unevaluated argument-expressions
186 It is possible to use an anonymous Lisp macro just like an anonymous
187 function, but this is never done, because it does not make sense to pass
188 an anonymous macro to functionals such as @code{mapcar}. In practice,
189 all Lisp macros have names, and they are usually defined with the
190 special form @code{defmacro}.
192 @defspec defmacro name argument-list body-forms@dots{}
193 @code{defmacro} defines the symbol @var{name} as a macro that looks
197 (macro lambda @var{argument-list} . @var{body-forms})
200 This macro object is stored in the function cell of @var{name}. The
201 value returned by evaluating the @code{defmacro} form is @var{name}, but
202 usually we ignore this value.
204 The shape and meaning of @var{argument-list} is the same as in a
205 function, and the keywords @code{&rest} and @code{&optional} may be used
206 (@pxref{Argument List}). Macros may have a documentation string, but
207 any @code{interactive} declaration is ignored since macros cannot be
208 called interactively.
214 @cindex backquote (list substitution)
215 @cindex ` (list substitution)
218 Macros often need to construct large list structures from a mixture of
219 constants and nonconstant parts. To make this easier, use the macro
220 @samp{`} (often called @dfn{backquote}).
222 Backquote allows you to quote a list, but selectively evaluate
223 elements of that list. In the simplest case, it is identical to the
224 special form @code{quote} (@pxref{Quoting}). For example, these
225 two forms yield identical results:
229 `(a list of (+ 2 3) elements)
230 @result{} (a list of (+ 2 3) elements)
233 '(a list of (+ 2 3) elements)
234 @result{} (a list of (+ 2 3) elements)
238 @findex , @r{(with Backquote)}
239 The special marker @samp{,} inside of the argument to backquote
240 indicates a value that isn't constant. Backquote evaluates the
241 argument of @samp{,} and puts the value in the list structure:
245 (list 'a 'list 'of (+ 2 3) 'elements)
246 @result{} (a list of 5 elements)
249 `(a list of ,(+ 2 3) elements)
250 @result{} (a list of 5 elements)
254 @findex ,@@ @r{(with Backquote)}
255 @cindex splicing (with backquote)
256 You can also @dfn{splice} an evaluated value into the resulting list,
257 using the special marker @samp{,@@}. The elements of the spliced list
258 become elements at the same level as the other elements of the resulting
259 list. The equivalent code without using @samp{`} is often unreadable.
260 Here are some examples:
264 (setq some-list '(2 3))
268 (cons 1 (append some-list '(4) some-list))
269 @result{} (1 2 3 4 2 3)
272 `(1 ,@@some-list 4 ,@@some-list)
273 @result{} (1 2 3 4 2 3)
277 (setq list '(hack foo bar))
278 @result{} (hack foo bar)
283 (cons 'words (append (cdr list) '(as elements)))))
284 @result{} (use the words foo bar as elements)
287 `(use the words ,@@(cdr list) as elements)
288 @result{} (use the words foo bar as elements)
294 @node Problems with Macros
295 @section Common Problems Using Macros
297 The basic facts of macro expansion have counterintuitive consequences.
298 This section describes some important consequences that can lead to
299 trouble, and rules to follow to avoid trouble.
302 * Argument Evaluation:: The expansion should evaluate each macro arg once.
303 * Surprising Local Vars:: Local variable bindings in the expansion
304 require special care.
305 * Eval During Expansion:: Don't evaluate them; put them in the expansion.
306 * Repeated Expansion:: Avoid depending on how many times expansion is done.
310 @node Argument Evaluation
311 @subsection Evaluating Macro Arguments Repeatedly
313 When defining a macro you must pay attention to the number of times
314 the arguments will be evaluated when the expansion is executed. The
315 following macro (used to facilitate iteration) illustrates the problem.
316 This macro allows us to write a simple ``for'' loop such as one might
322 (defmacro for (var from init to final do &rest body)
323 "Execute a simple \"for\" loop.
324 For example, (for i from 1 to 10 do (print i))."
325 (list 'let (list (list var init))
326 (cons 'while (cons (list '<= var final)
327 (append body (list (list 'inc var)))))))
332 (for i from 1 to 3 do
333 (setq square (* i i))
334 (princ (format "\n%d %d" i square)))
340 (setq square (* i i))
341 (princ (format "%d %d" i square))
354 (The arguments @code{from}, @code{to}, and @code{do} in this macro are
355 ``syntactic sugar''; they are entirely ignored. The idea is that you
356 will write noise words (such as @code{from}, @code{to}, and @code{do})
357 in those positions in the macro call.)
359 Here's an equivalent definition simplified through use of backquote:
363 (defmacro for (var from init to final do &rest body)
364 "Execute a simple \"for\" loop.
365 For example, (for i from 1 to 10 do (print i))."
367 (while (<= ,var ,final)
373 Both forms of this definition (with backquote and without) suffer from
374 the defect that @var{final} is evaluated on every iteration. If
375 @var{final} is a constant, this is not a problem. If it is a more
376 complex form, say @code{(long-complex-calculation x)}, this can slow
377 down the execution significantly. If @var{final} has side effects,
378 executing it more than once is probably incorrect.
380 @cindex macro argument evaluation
381 A well-designed macro definition takes steps to avoid this problem by
382 producing an expansion that evaluates the argument expressions exactly
383 once unless repeated evaluation is part of the intended purpose of the
384 macro. Here is a correct expansion for the @code{for} macro:
391 (setq square (* i i))
392 (princ (format "%d %d" i square))
397 Here is a macro definition that creates this expansion:
401 (defmacro for (var from init to final do &rest body)
402 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
411 Unfortunately, this introduces another problem.
413 Proceed to the following node.
417 @node Surprising Local Vars
418 @subsection Local Variables in Macro Expansions
421 In the previous section, the definition of @code{for} was fixed as
422 follows to make the expansion evaluate the macro arguments the proper
427 (defmacro for (var from init to final do &rest body)
428 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
440 The new definition of @code{for} has a new problem: it introduces a
441 local variable named @code{max} which the user does not expect. This
442 causes trouble in examples such as the following:
447 (for x from 0 to 10 do
448 (let ((this (frob x)))
455 The references to @code{max} inside the body of the @code{for}, which
456 are supposed to refer to the user's binding of @code{max}, really access
457 the binding made by @code{for}.
459 The way to correct this is to use an uninterned symbol instead of
460 @code{max} (@pxref{Creating Symbols}). The uninterned symbol can be
461 bound and referred to just like any other symbol, but since it is
462 created by @code{for}, we know that it cannot already appear in the
463 user's program. Since it is not interned, there is no way the user can
464 put it into the program later. It will never appear anywhere except
465 where put by @code{for}. Here is a definition of @code{for} that works
470 (defmacro for (var from init to final do &rest body)
471 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
472 (let ((tempvar (make-symbol "max")))
475 (while (<= ,var ,tempvar)
482 This creates an uninterned symbol named @code{max} and puts it in the
483 expansion instead of the usual interned symbol @code{max} that appears
484 in expressions ordinarily.
487 @node Eval During Expansion
488 @subsection Evaluating Macro Arguments in Expansion
490 Another problem can happen if you evaluate any of the macro argument
491 expressions during the computation of the expansion, such as by calling
492 @code{eval} (@pxref{Eval}). If the argument is supposed to refer to the
493 user's variables, you may have trouble if the user happens to use a
494 variable with the same name as one of the macro arguments. Inside the
495 macro body, the macro argument binding is the most local binding of this
496 variable, so any references inside the form being evaluated do refer
497 to it. Here is an example:
502 (list 'setq (eval a) t))
507 (foo x) @expansion{} (setq b t)
508 @result{} t ; @r{and @code{b} has been set.}
511 (foo a) @expansion{} (setq a t)
512 @result{} t ; @r{but this set @code{a}, not @code{c}.}
517 It makes a difference whether the user's variable is named @code{a} or
518 @code{x}, because @code{a} conflicts with the macro argument variable
521 Another reason not to call @code{eval} in a macro definition is that
522 it probably won't do what you intend in a compiled program. The
523 byte-compiler runs macro definitions while compiling the program, when
524 the program's own computations (which you might have wished to access
525 with @code{eval}) don't occur and its local variable bindings don't
528 The safe way to work with the run-time value of an expression is to
529 put the expression into the macro expansion, so that its value is
530 computed as part of executing the expansion.
533 @node Repeated Expansion
534 @subsection How Many Times is the Macro Expanded?
536 Occasionally problems result from the fact that a macro call is
537 expanded each time it is evaluated in an interpreted function, but is
538 expanded only once (during compilation) for a compiled function. If the
539 macro definition has side effects, they will work differently depending
540 on how many times the macro is expanded.
542 In particular, constructing objects is a kind of side effect. If the
543 macro is called once, then the objects are constructed only once. In
544 other words, the same structure of objects is used each time the macro
545 call is executed. In interpreted operation, the macro is reexpanded
546 each time, producing a fresh collection of objects each time. Usually
547 this does not matter---the objects have the same contents whether they
548 are shared or not. But if the surrounding program does side effects
549 on the objects, it makes a difference whether they are shared. Here is
554 (defmacro empty-object ()
555 (list 'quote (cons nil nil)))
559 (defun initialize (condition)
560 (let ((object (empty-object)))
562 (setcar object condition))
568 If @code{initialize} is interpreted, a new list @code{(nil)} is
569 constructed each time @code{initialize} is called. Thus, no side effect
570 survives between calls. If @code{initialize} is compiled, then the
571 macro @code{empty-object} is expanded during compilation, producing a
572 single ``constant'' @code{(nil)} that is reused and altered each time
573 @code{initialize} is called.
575 One way to avoid pathological cases like this is to think of
576 @code{empty-object} as a funny kind of constant, not as a memory
577 allocation construct. You wouldn't use @code{setcar} on a constant such
578 as @code{'(nil)}, so naturally you won't use it on @code{(empty-object)}