2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 2001, 2002,
4 @c 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 @c See the file elisp.texi for copying conditions.
6 @setfilename ../info/macros
7 @node Macros, Customization, Functions, Top
11 @dfn{Macros} enable you to define new control constructs and other
12 language features. A macro is defined much like a function, but instead
13 of telling how to compute a value, it tells how to compute another Lisp
14 expression which will in turn compute the value. We call this
15 expression the @dfn{expansion} of the macro.
17 Macros can do this because they operate on the unevaluated expressions
18 for the arguments, not on the argument values as functions do. They can
19 therefore construct an expansion containing these argument expressions
22 If you are using a macro to do something an ordinary function could
23 do, just for the sake of speed, consider using an inline function
24 instead. @xref{Inline Functions}.
27 * Simple Macro:: A basic example.
28 * Expansion:: How, when and why macros are expanded.
29 * Compiling Macros:: How macros are expanded by the compiler.
30 * Defining Macros:: How to write a macro definition.
31 * Backquote:: Easier construction of list structure.
32 * Problems with Macros:: Don't evaluate the macro arguments too many times.
33 Don't hide the user's variables.
34 * Indenting Macros:: Specifying how to indent macro calls.
38 @section A Simple Example of a Macro
40 Suppose we would like to define a Lisp construct to increment a
41 variable value, much like the @code{++} operator in C. We would like to
42 write @code{(inc x)} and have the effect of @code{(setq x (1+ x))}.
43 Here's a macro definition that does the job:
49 (list 'setq var (list '1+ var)))
53 When this is called with @code{(inc x)}, the argument @var{var} is the
54 symbol @code{x}---@emph{not} the @emph{value} of @code{x}, as it would
55 be in a function. The body of the macro uses this to construct the
56 expansion, which is @code{(setq x (1+ x))}. Once the macro definition
57 returns this expansion, Lisp proceeds to evaluate it, thus incrementing
61 @section Expansion of a Macro Call
62 @cindex expansion of macros
65 A macro call looks just like a function call in that it is a list which
66 starts with the name of the macro. The rest of the elements of the list
67 are the arguments of the macro.
69 Evaluation of the macro call begins like evaluation of a function call
70 except for one crucial difference: the macro arguments are the actual
71 expressions appearing in the macro call. They are not evaluated before
72 they are given to the macro definition. By contrast, the arguments of a
73 function are results of evaluating the elements of the function call
76 Having obtained the arguments, Lisp invokes the macro definition just
77 as a function is invoked. The argument variables of the macro are bound
78 to the argument values from the macro call, or to a list of them in the
79 case of a @code{&rest} argument. And the macro body executes and
80 returns its value just as a function body does.
82 The second crucial difference between macros and functions is that the
83 value returned by the macro body is not the value of the macro call.
84 Instead, it is an alternate expression for computing that value, also
85 known as the @dfn{expansion} of the macro. The Lisp interpreter
86 proceeds to evaluate the expansion as soon as it comes back from the
89 Since the expansion is evaluated in the normal manner, it may contain
90 calls to other macros. It may even be a call to the same macro, though
93 You can see the expansion of a given macro call by calling
96 @defun macroexpand form &optional environment
97 @cindex macro expansion
98 This function expands @var{form}, if it is a macro call. If the result
99 is another macro call, it is expanded in turn, until something which is
100 not a macro call results. That is the value returned by
101 @code{macroexpand}. If @var{form} is not a macro call to begin with, it
102 is returned as given.
104 Note that @code{macroexpand} does not look at the subexpressions of
105 @var{form} (although some macro definitions may do so). Even if they
106 are macro calls themselves, @code{macroexpand} does not expand them.
108 The function @code{macroexpand} does not expand calls to inline functions.
109 Normally there is no need for that, since a call to an inline function is
110 no harder to understand than a call to an ordinary function.
112 If @var{environment} is provided, it specifies an alist of macro
113 definitions that shadow the currently defined macros. Byte compilation
119 (list 'setq var (list '1+ var)))
124 (macroexpand '(inc r))
125 @result{} (setq r (1+ r))
129 (defmacro inc2 (var1 var2)
130 (list 'progn (list 'inc var1) (list 'inc var2)))
135 (macroexpand '(inc2 r s))
136 @result{} (progn (inc r) (inc s)) ; @r{@code{inc} not expanded here.}
142 @defun macroexpand-all form &optional environment
143 @cindex macro expansion in entire form
144 @code{macroexpand-all} expands macros like @code{macroexpand}, but
145 will look for and expand all macros in @var{form}, not just at the
146 top-level. If no macros are expanded, the return value is @code{eq}
149 Repeating the example used for @code{macroexpand} above with
150 @code{macroexpand-all}, we see that @code{macroexpand-all} @emph{does}
151 expand the embedded calls to @code{inc}:
154 (macroexpand-all '(inc2 r s))
155 @result{} (progn (setq r (1+ r)) (setq s (1+ s)))
160 @node Compiling Macros
161 @section Macros and Byte Compilation
162 @cindex byte-compiling macros
164 You might ask why we take the trouble to compute an expansion for a
165 macro and then evaluate the expansion. Why not have the macro body
166 produce the desired results directly? The reason has to do with
169 When a macro call appears in a Lisp program being compiled, the Lisp
170 compiler calls the macro definition just as the interpreter would, and
171 receives an expansion. But instead of evaluating this expansion, it
172 compiles the expansion as if it had appeared directly in the program.
173 As a result, the compiled code produces the value and side effects
174 intended for the macro, but executes at full compiled speed. This would
175 not work if the macro body computed the value and side effects
176 itself---they would be computed at compile time, which is not useful.
178 In order for compilation of macro calls to work, the macros must
179 already be defined in Lisp when the calls to them are compiled. The
180 compiler has a special feature to help you do this: if a file being
181 compiled contains a @code{defmacro} form, the macro is defined
182 temporarily for the rest of the compilation of that file. To make this
183 feature work, you must put the @code{defmacro} in the same file where it
184 is used, and before its first use.
186 Byte-compiling a file executes any @code{require} calls at top-level
187 in the file. This is in case the file needs the required packages for
188 proper compilation. One way to ensure that necessary macro definitions
189 are available during compilation is to require the files that define
190 them (@pxref{Named Features}). To avoid loading the macro definition files
191 when someone @emph{runs} the compiled program, write
192 @code{eval-when-compile} around the @code{require} calls (@pxref{Eval
195 @node Defining Macros
196 @section Defining Macros
198 A Lisp macro is a list whose @sc{car} is @code{macro}. Its @sc{cdr} should
199 be a function; expansion of the macro works by applying the function
200 (with @code{apply}) to the list of unevaluated argument-expressions
203 It is possible to use an anonymous Lisp macro just like an anonymous
204 function, but this is never done, because it does not make sense to pass
205 an anonymous macro to functionals such as @code{mapcar}. In practice,
206 all Lisp macros have names, and they are usually defined with the
207 special form @code{defmacro}.
209 @defspec defmacro name argument-list body-forms@dots{}
210 @code{defmacro} defines the symbol @var{name} as a macro that looks
214 (macro lambda @var{argument-list} . @var{body-forms})
217 (Note that the @sc{cdr} of this list is a function---a lambda expression.)
218 This macro object is stored in the function cell of @var{name}. The
219 value returned by evaluating the @code{defmacro} form is @var{name}, but
220 usually we ignore this value.
222 The shape and meaning of @var{argument-list} is the same as in a
223 function, and the keywords @code{&rest} and @code{&optional} may be used
224 (@pxref{Argument List}). Macros may have a documentation string, but
225 any @code{interactive} declaration is ignored since macros cannot be
226 called interactively.
229 The body of the macro definition can include a @code{declare} form,
230 which can specify how @key{TAB} should indent macro calls, and how to
231 step through them for Edebug.
233 @defmac declare @var{specs}@dots{}
234 @anchor{Definition of declare}
235 A @code{declare} form is used in a macro definition to specify various
236 additional information about it. Two kinds of specification are
240 @item (debug @var{edebug-form-spec})
241 Specify how to step through macro calls for Edebug.
242 @xref{Instrumenting Macro Calls}.
244 @item (indent @var{indent-spec})
245 Specify how to indent calls to this macro. @xref{Indenting Macros},
249 A @code{declare} form only has its special effect in the body of a
250 @code{defmacro} form if it immediately follows the documentation
251 string, if present, or the argument list otherwise. (Strictly
252 speaking, @emph{several} @code{declare} forms can follow the
253 documentation string or argument list, but since a @code{declare} form
254 can have several @var{specs}, they can always be combined into a
255 single form.) When used at other places in a @code{defmacro} form, or
256 outside a @code{defmacro} form, @code{declare} just returns @code{nil}
257 without evaluating any @var{specs}.
260 No macro absolutely needs a @code{declare} form, because that form
261 has no effect on how the macro expands, on what the macro means in the
262 program. It only affects secondary features: indentation and Edebug.
266 @cindex backquote (list substitution)
267 @cindex ` (list substitution)
270 Macros often need to construct large list structures from a mixture of
271 constants and nonconstant parts. To make this easier, use the @samp{`}
272 syntax (usually called @dfn{backquote}).
274 Backquote allows you to quote a list, but selectively evaluate
275 elements of that list. In the simplest case, it is identical to the
276 special form @code{quote} (@pxref{Quoting}). For example, these
277 two forms yield identical results:
281 `(a list of (+ 2 3) elements)
282 @result{} (a list of (+ 2 3) elements)
285 '(a list of (+ 2 3) elements)
286 @result{} (a list of (+ 2 3) elements)
290 @findex , @r{(with Backquote)}
291 The special marker @samp{,} inside of the argument to backquote
292 indicates a value that isn't constant. Backquote evaluates the
293 argument of @samp{,} and puts the value in the list structure:
297 (list 'a 'list 'of (+ 2 3) 'elements)
298 @result{} (a list of 5 elements)
301 `(a list of ,(+ 2 3) elements)
302 @result{} (a list of 5 elements)
306 Substitution with @samp{,} is allowed at deeper levels of the list
307 structure also. For example:
311 (defmacro t-becomes-nil (variable)
312 `(if (eq ,variable t)
313 (setq ,variable nil)))
318 @equiv{} (if (eq foo t) (setq foo nil))
322 @findex ,@@ @r{(with Backquote)}
323 @cindex splicing (with backquote)
324 You can also @dfn{splice} an evaluated value into the resulting list,
325 using the special marker @samp{,@@}. The elements of the spliced list
326 become elements at the same level as the other elements of the resulting
327 list. The equivalent code without using @samp{`} is often unreadable.
328 Here are some examples:
332 (setq some-list '(2 3))
336 (cons 1 (append some-list '(4) some-list))
337 @result{} (1 2 3 4 2 3)
340 `(1 ,@@some-list 4 ,@@some-list)
341 @result{} (1 2 3 4 2 3)
345 (setq list '(hack foo bar))
346 @result{} (hack foo bar)
351 (cons 'words (append (cdr list) '(as elements)))))
352 @result{} (use the words foo bar as elements)
355 `(use the words ,@@(cdr list) as elements)
356 @result{} (use the words foo bar as elements)
360 In old Emacs versions, before version 19.29, @samp{`} used a different
361 syntax which required an extra level of parentheses around the entire
362 backquote construct. Likewise, each @samp{,} or @samp{,@@} substitution
363 required an extra level of parentheses surrounding both the @samp{,} or
364 @samp{,@@} and the following expression. The old syntax required
365 whitespace between the @samp{`}, @samp{,} or @samp{,@@} and the
366 following expression.
368 This syntax is still accepted, for compatibility with old Emacs
369 versions, but we recommend not using it in new programs.
371 @node Problems with Macros
372 @section Common Problems Using Macros
374 The basic facts of macro expansion have counterintuitive consequences.
375 This section describes some important consequences that can lead to
376 trouble, and rules to follow to avoid trouble.
379 * Wrong Time:: Do the work in the expansion, not in the macro.
380 * Argument Evaluation:: The expansion should evaluate each macro arg once.
381 * Surprising Local Vars:: Local variable bindings in the expansion
382 require special care.
383 * Eval During Expansion:: Don't evaluate them; put them in the expansion.
384 * Repeated Expansion:: Avoid depending on how many times expansion is done.
388 @subsection Wrong Time
390 The most common problem in writing macros is doing some of the
391 real work prematurely---while expanding the macro, rather than in the
392 expansion itself. For instance, one real package had this macro
396 (defmacro my-set-buffer-multibyte (arg)
397 (if (fboundp 'set-buffer-multibyte)
398 (set-buffer-multibyte arg)))
401 With this erroneous macro definition, the program worked fine when
402 interpreted but failed when compiled. This macro definition called
403 @code{set-buffer-multibyte} during compilation, which was wrong, and
404 then did nothing when the compiled package was run. The definition
405 that the programmer really wanted was this:
408 (defmacro my-set-buffer-multibyte (arg)
409 (if (fboundp 'set-buffer-multibyte)
410 `(set-buffer-multibyte ,arg)))
414 This macro expands, if appropriate, into a call to
415 @code{set-buffer-multibyte} that will be executed when the compiled
416 program is actually run.
418 @node Argument Evaluation
419 @subsection Evaluating Macro Arguments Repeatedly
421 When defining a macro you must pay attention to the number of times
422 the arguments will be evaluated when the expansion is executed. The
423 following macro (used to facilitate iteration) illustrates the problem.
424 This macro allows us to write a simple ``for'' loop such as one might
430 (defmacro for (var from init to final do &rest body)
431 "Execute a simple \"for\" loop.
432 For example, (for i from 1 to 10 do (print i))."
433 (list 'let (list (list var init))
434 (cons 'while (cons (list '<= var final)
435 (append body (list (list 'inc var)))))))
440 (for i from 1 to 3 do
441 (setq square (* i i))
442 (princ (format "\n%d %d" i square)))
448 (setq square (* i i))
449 (princ (format "\n%d %d" i square))
462 The arguments @code{from}, @code{to}, and @code{do} in this macro are
463 ``syntactic sugar''; they are entirely ignored. The idea is that you
464 will write noise words (such as @code{from}, @code{to}, and @code{do})
465 in those positions in the macro call.
467 Here's an equivalent definition simplified through use of backquote:
471 (defmacro for (var from init to final do &rest body)
472 "Execute a simple \"for\" loop.
473 For example, (for i from 1 to 10 do (print i))."
475 (while (<= ,var ,final)
481 Both forms of this definition (with backquote and without) suffer from
482 the defect that @var{final} is evaluated on every iteration. If
483 @var{final} is a constant, this is not a problem. If it is a more
484 complex form, say @code{(long-complex-calculation x)}, this can slow
485 down the execution significantly. If @var{final} has side effects,
486 executing it more than once is probably incorrect.
488 @cindex macro argument evaluation
489 A well-designed macro definition takes steps to avoid this problem by
490 producing an expansion that evaluates the argument expressions exactly
491 once unless repeated evaluation is part of the intended purpose of the
492 macro. Here is a correct expansion for the @code{for} macro:
499 (setq square (* i i))
500 (princ (format "%d %d" i square))
505 Here is a macro definition that creates this expansion:
509 (defmacro for (var from init to final do &rest body)
510 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
519 Unfortunately, this fix introduces another problem,
520 described in the following section.
522 @node Surprising Local Vars
523 @subsection Local Variables in Macro Expansions
526 In the previous section, the definition of @code{for} was fixed as
527 follows to make the expansion evaluate the macro arguments the proper
532 (defmacro for (var from init to final do &rest body)
533 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
545 The new definition of @code{for} has a new problem: it introduces a
546 local variable named @code{max} which the user does not expect. This
547 causes trouble in examples such as the following:
552 (for x from 0 to 10 do
553 (let ((this (frob x)))
560 The references to @code{max} inside the body of the @code{for}, which
561 are supposed to refer to the user's binding of @code{max}, really access
562 the binding made by @code{for}.
564 The way to correct this is to use an uninterned symbol instead of
565 @code{max} (@pxref{Creating Symbols}). The uninterned symbol can be
566 bound and referred to just like any other symbol, but since it is
567 created by @code{for}, we know that it cannot already appear in the
568 user's program. Since it is not interned, there is no way the user can
569 put it into the program later. It will never appear anywhere except
570 where put by @code{for}. Here is a definition of @code{for} that works
575 (defmacro for (var from init to final do &rest body)
576 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
577 (let ((tempvar (make-symbol "max")))
580 (while (<= ,var ,tempvar)
587 This creates an uninterned symbol named @code{max} and puts it in the
588 expansion instead of the usual interned symbol @code{max} that appears
589 in expressions ordinarily.
591 @node Eval During Expansion
592 @subsection Evaluating Macro Arguments in Expansion
594 Another problem can happen if the macro definition itself
595 evaluates any of the macro argument expressions, such as by calling
596 @code{eval} (@pxref{Eval}). If the argument is supposed to refer to the
597 user's variables, you may have trouble if the user happens to use a
598 variable with the same name as one of the macro arguments. Inside the
599 macro body, the macro argument binding is the most local binding of this
600 variable, so any references inside the form being evaluated do refer to
601 it. Here is an example:
606 (list 'setq (eval a) t))
611 (foo x) @expansion{} (setq b t)
612 @result{} t ; @r{and @code{b} has been set.}
615 (foo a) @expansion{} (setq a t)
616 @result{} t ; @r{but this set @code{a}, not @code{c}.}
621 It makes a difference whether the user's variable is named @code{a} or
622 @code{x}, because @code{a} conflicts with the macro argument variable
625 Another problem with calling @code{eval} in a macro definition is that
626 it probably won't do what you intend in a compiled program. The
627 byte-compiler runs macro definitions while compiling the program, when
628 the program's own computations (which you might have wished to access
629 with @code{eval}) don't occur and its local variable bindings don't
632 To avoid these problems, @strong{don't evaluate an argument expression
633 while computing the macro expansion}. Instead, substitute the
634 expression into the macro expansion, so that its value will be computed
635 as part of executing the expansion. This is how the other examples in
638 @node Repeated Expansion
639 @subsection How Many Times is the Macro Expanded?
641 Occasionally problems result from the fact that a macro call is
642 expanded each time it is evaluated in an interpreted function, but is
643 expanded only once (during compilation) for a compiled function. If the
644 macro definition has side effects, they will work differently depending
645 on how many times the macro is expanded.
647 Therefore, you should avoid side effects in computation of the
648 macro expansion, unless you really know what you are doing.
650 One special kind of side effect can't be avoided: constructing Lisp
651 objects. Almost all macro expansions include constructed lists; that is
652 the whole point of most macros. This is usually safe; there is just one
653 case where you must be careful: when the object you construct is part of a
654 quoted constant in the macro expansion.
656 If the macro is expanded just once, in compilation, then the object is
657 constructed just once, during compilation. But in interpreted
658 execution, the macro is expanded each time the macro call runs, and this
659 means a new object is constructed each time.
661 In most clean Lisp code, this difference won't matter. It can matter
662 only if you perform side-effects on the objects constructed by the macro
663 definition. Thus, to avoid trouble, @strong{avoid side effects on
664 objects constructed by macro definitions}. Here is an example of how
665 such side effects can get you into trouble:
669 (defmacro empty-object ()
670 (list 'quote (cons nil nil)))
674 (defun initialize (condition)
675 (let ((object (empty-object)))
677 (setcar object condition))
683 If @code{initialize} is interpreted, a new list @code{(nil)} is
684 constructed each time @code{initialize} is called. Thus, no side effect
685 survives between calls. If @code{initialize} is compiled, then the
686 macro @code{empty-object} is expanded during compilation, producing a
687 single ``constant'' @code{(nil)} that is reused and altered each time
688 @code{initialize} is called.
690 One way to avoid pathological cases like this is to think of
691 @code{empty-object} as a funny kind of constant, not as a memory
692 allocation construct. You wouldn't use @code{setcar} on a constant such
693 as @code{'(nil)}, so naturally you won't use it on @code{(empty-object)}
696 @node Indenting Macros
697 @section Indenting Macros
699 You can use the @code{declare} form in the macro definition to
700 specify how to @key{TAB} should indent indent calls to the macro. You
704 (declare (indent @var{indent-spec}))
708 Here are the possibilities for @var{indent-spec}:
712 This is the same as no property---use the standard indentation pattern.
714 Handle this function like a @samp{def} construct: treat the second
715 line as the start of a @dfn{body}.
716 @item an integer, @var{number}
717 The first @var{number} arguments of the function are
718 @dfn{distinguished} arguments; the rest are considered the body
719 of the expression. A line in the expression is indented according to
720 whether the first argument on it is distinguished or not. If the
721 argument is part of the body, the line is indented @code{lisp-body-indent}
722 more columns than the open-parenthesis starting the containing
723 expression. If the argument is distinguished and is either the first
724 or second argument, it is indented @emph{twice} that many extra columns.
725 If the argument is distinguished and not the first or second argument,
726 the line uses the standard pattern.
727 @item a symbol, @var{symbol}
728 @var{symbol} should be a function name; that function is called to
729 calculate the indentation of a line within this expression. The
730 function receives two arguments:
733 The value returned by @code{parse-partial-sexp} (a Lisp primitive for
734 indentation and nesting computation) when it parses up to the
735 beginning of this line.
737 The position at which the line being indented begins.
740 It should return either a number, which is the number of columns of
741 indentation for that line, or a list whose car is such a number. The
742 difference between returning a number and returning a list is that a
743 number says that all following lines at the same nesting level should
744 be indented just like this one; a list says that following lines might
745 call for different indentations. This makes a difference when the
746 indentation is being computed by @kbd{C-M-q}; if the value is a
747 number, @kbd{C-M-q} need not recalculate indentation for the following
748 lines until the end of the list.
752 arch-tag: d4cce66d-1047-45c3-bfde-db6719d6e82b