2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990-1995, 1998, 2001-2012 Free Software Foundation, Inc.
4 @c See the file elisp.texi for copying conditions.
9 @dfn{Macros} enable you to define new control constructs and other
10 language features. A macro is defined much like a function, but instead
11 of telling how to compute a value, it tells how to compute another Lisp
12 expression which will in turn compute the value. We call this
13 expression the @dfn{expansion} of the macro.
15 Macros can do this because they operate on the unevaluated expressions
16 for the arguments, not on the argument values as functions do. They can
17 therefore construct an expansion containing these argument expressions
20 If you are using a macro to do something an ordinary function could
21 do, just for the sake of speed, consider using an inline function
22 instead. @xref{Inline Functions}.
25 * Simple Macro:: A basic example.
26 * Expansion:: How, when and why macros are expanded.
27 * Compiling Macros:: How macros are expanded by the compiler.
28 * Defining Macros:: How to write a macro definition.
29 * Problems with Macros:: Don't evaluate the macro arguments too many times.
30 Don't hide the user's variables.
31 * Indenting Macros:: Specifying how to indent macro calls.
35 @section A Simple Example of a Macro
37 Suppose we would like to define a Lisp construct to increment a
38 variable value, much like the @code{++} operator in C. We would like to
39 write @code{(inc x)} and have the effect of @code{(setq x (1+ x))}.
40 Here's a macro definition that does the job:
46 (list 'setq var (list '1+ var)))
50 When this is called with @code{(inc x)}, the argument @var{var} is the
51 symbol @code{x}---@emph{not} the @emph{value} of @code{x}, as it would
52 be in a function. The body of the macro uses this to construct the
53 expansion, which is @code{(setq x (1+ x))}. Once the macro definition
54 returns this expansion, Lisp proceeds to evaluate it, thus incrementing
58 @section Expansion of a Macro Call
59 @cindex expansion of macros
62 A macro call looks just like a function call in that it is a list which
63 starts with the name of the macro. The rest of the elements of the list
64 are the arguments of the macro.
66 Evaluation of the macro call begins like evaluation of a function call
67 except for one crucial difference: the macro arguments are the actual
68 expressions appearing in the macro call. They are not evaluated before
69 they are given to the macro definition. By contrast, the arguments of a
70 function are results of evaluating the elements of the function call
73 Having obtained the arguments, Lisp invokes the macro definition just
74 as a function is invoked. The argument variables of the macro are bound
75 to the argument values from the macro call, or to a list of them in the
76 case of a @code{&rest} argument. And the macro body executes and
77 returns its value just as a function body does.
79 The second crucial difference between macros and functions is that
80 the value returned by the macro body is an alternate Lisp expression,
81 also known as the @dfn{expansion} of the macro. The Lisp interpreter
82 proceeds to evaluate the expansion as soon as it comes back from the
85 Since the expansion is evaluated in the normal manner, it may contain
86 calls to other macros. It may even be a call to the same macro, though
89 You can see the expansion of a given macro call by calling
92 @defun macroexpand form &optional environment
93 @cindex macro expansion
94 This function expands @var{form}, if it is a macro call. If the result
95 is another macro call, it is expanded in turn, until something which is
96 not a macro call results. That is the value returned by
97 @code{macroexpand}. If @var{form} is not a macro call to begin with, it
100 Note that @code{macroexpand} does not look at the subexpressions of
101 @var{form} (although some macro definitions may do so). Even if they
102 are macro calls themselves, @code{macroexpand} does not expand them.
104 The function @code{macroexpand} does not expand calls to inline functions.
105 Normally there is no need for that, since a call to an inline function is
106 no harder to understand than a call to an ordinary function.
108 If @var{environment} is provided, it specifies an alist of macro
109 definitions that shadow the currently defined macros. Byte compilation
115 (list 'setq var (list '1+ var)))
119 (macroexpand '(inc r))
120 @result{} (setq r (1+ r))
124 (defmacro inc2 (var1 var2)
125 (list 'progn (list 'inc var1) (list 'inc var2)))
129 (macroexpand '(inc2 r s))
130 @result{} (progn (inc r) (inc s)) ; @r{@code{inc} not expanded here.}
136 @defun macroexpand-all form &optional environment
137 @code{macroexpand-all} expands macros like @code{macroexpand}, but
138 will look for and expand all macros in @var{form}, not just at the
139 top-level. If no macros are expanded, the return value is @code{eq}
142 Repeating the example used for @code{macroexpand} above with
143 @code{macroexpand-all}, we see that @code{macroexpand-all} @emph{does}
144 expand the embedded calls to @code{inc}:
147 (macroexpand-all '(inc2 r s))
148 @result{} (progn (setq r (1+ r)) (setq s (1+ s)))
153 @node Compiling Macros
154 @section Macros and Byte Compilation
155 @cindex byte-compiling macros
157 You might ask why we take the trouble to compute an expansion for a
158 macro and then evaluate the expansion. Why not have the macro body
159 produce the desired results directly? The reason has to do with
162 When a macro call appears in a Lisp program being compiled, the Lisp
163 compiler calls the macro definition just as the interpreter would, and
164 receives an expansion. But instead of evaluating this expansion, it
165 compiles the expansion as if it had appeared directly in the program.
166 As a result, the compiled code produces the value and side effects
167 intended for the macro, but executes at full compiled speed. This would
168 not work if the macro body computed the value and side effects
169 itself---they would be computed at compile time, which is not useful.
171 In order for compilation of macro calls to work, the macros must
172 already be defined in Lisp when the calls to them are compiled. The
173 compiler has a special feature to help you do this: if a file being
174 compiled contains a @code{defmacro} form, the macro is defined
175 temporarily for the rest of the compilation of that file.
177 Byte-compiling a file also executes any @code{require} calls at
178 top-level in the file, so you can ensure that necessary macro
179 definitions are available during compilation by requiring the files
180 that define them (@pxref{Named Features}). To avoid loading the macro
181 definition files when someone @emph{runs} the compiled program, write
182 @code{eval-when-compile} around the @code{require} calls (@pxref{Eval
185 @node Defining Macros
186 @section Defining Macros
188 A Lisp macro is a list whose @sc{car} is @code{macro}. Its @sc{cdr} should
189 be a function; expansion of the macro works by applying the function
190 (with @code{apply}) to the list of unevaluated argument-expressions
193 It is possible to use an anonymous Lisp macro just like an anonymous
194 function, but this is never done, because it does not make sense to pass
195 an anonymous macro to functionals such as @code{mapcar}. In practice,
196 all Lisp macros have names, and they are usually defined with the
197 special form @code{defmacro}.
199 @defspec defmacro name argument-list body-forms@dots{}
200 @code{defmacro} defines the symbol @var{name} as a macro that looks
204 (macro lambda @var{argument-list} . @var{body-forms})
207 (Note that the @sc{cdr} of this list is a function---a lambda expression.)
208 This macro object is stored in the function cell of @var{name}. Its return
209 value is @emph{undefined}.
211 The shape and meaning of @var{argument-list} is the same as in a
212 function, and the keywords @code{&rest} and @code{&optional} may be used
213 (@pxref{Argument List}). Macros may have a documentation string, but
214 any @code{interactive} declaration is ignored since macros cannot be
215 called interactively.
218 Macros often need to construct large list structures from a mixture
219 of constants and nonconstant parts. To make this easier, use the
220 @samp{`} syntax (@pxref{Backquote}). For example:
225 (defmacro t-becomes-nil (variable)
226 `(if (eq ,variable t)
227 (setq ,variable nil)))
232 @equiv{} (if (eq foo t) (setq foo nil))
237 The body of a macro definition can include a @code{declare} form,
238 which can specify how @key{TAB} should indent macro calls, and how to
239 step through them for Edebug.
241 @defmac declare @var{specs}@dots{}
242 @anchor{Definition of declare}
243 A @code{declare} form is used in a macro definition to specify various
244 additional information about it. The following specifications are
248 @item (debug @var{edebug-form-spec})
249 Specify how to step through macro calls for Edebug.
250 @xref{Instrumenting Macro Calls}.
252 @item (indent @var{indent-spec})
253 Specify how to indent calls to this macro. @xref{Indenting Macros},
256 @item (doc-string @var{number})
257 Specify which element of the macro is the documentation string, if
261 A @code{declare} form only has its special effect in the body of a
262 @code{defmacro} form if it immediately follows the documentation
263 string, if present, or the argument list otherwise. (Strictly
264 speaking, @emph{several} @code{declare} forms can follow the
265 documentation string or argument list, but since a @code{declare} form
266 can have several @var{specs}, they can always be combined into a
267 single form.) When used at other places in a @code{defmacro} form, or
268 outside a @code{defmacro} form, @code{declare} just returns @code{nil}
269 without evaluating any @var{specs}.
272 No macro absolutely needs a @code{declare} form, because that form
273 has no effect on how the macro expands, on what the macro means in the
274 program. It only affects the secondary features listed above.
276 @node Problems with Macros
277 @section Common Problems Using Macros
279 Macro expansion can have counterintuitive consequences. This
280 section describes some important consequences that can lead to
281 trouble, and rules to follow to avoid trouble.
284 * Wrong Time:: Do the work in the expansion, not in the macro.
285 * Argument Evaluation:: The expansion should evaluate each macro arg once.
286 * Surprising Local Vars:: Local variable bindings in the expansion
287 require special care.
288 * Eval During Expansion:: Don't evaluate them; put them in the expansion.
289 * Repeated Expansion:: Avoid depending on how many times expansion is done.
293 @subsection Wrong Time
295 The most common problem in writing macros is doing some of the
296 real work prematurely---while expanding the macro, rather than in the
297 expansion itself. For instance, one real package had this macro
301 (defmacro my-set-buffer-multibyte (arg)
302 (if (fboundp 'set-buffer-multibyte)
303 (set-buffer-multibyte arg)))
306 With this erroneous macro definition, the program worked fine when
307 interpreted but failed when compiled. This macro definition called
308 @code{set-buffer-multibyte} during compilation, which was wrong, and
309 then did nothing when the compiled package was run. The definition
310 that the programmer really wanted was this:
313 (defmacro my-set-buffer-multibyte (arg)
314 (if (fboundp 'set-buffer-multibyte)
315 `(set-buffer-multibyte ,arg)))
319 This macro expands, if appropriate, into a call to
320 @code{set-buffer-multibyte} that will be executed when the compiled
321 program is actually run.
323 @node Argument Evaluation
324 @subsection Evaluating Macro Arguments Repeatedly
326 When defining a macro you must pay attention to the number of times
327 the arguments will be evaluated when the expansion is executed. The
328 following macro (used to facilitate iteration) illustrates the
329 problem. This macro allows us to write a ``for'' loop construct.
334 (defmacro for (var from init to final do &rest body)
335 "Execute a simple \"for\" loop.
336 For example, (for i from 1 to 10 do (print i))."
337 (list 'let (list (list var init))
339 (cons (list '<= var final)
340 (append body (list (list 'inc var)))))))
344 (for i from 1 to 3 do
345 (setq square (* i i))
346 (princ (format "\n%d %d" i square)))
352 (setq square (* i i))
353 (princ (format "\n%d %d" i square))
366 The arguments @code{from}, @code{to}, and @code{do} in this macro are
367 ``syntactic sugar''; they are entirely ignored. The idea is that you
368 will write noise words (such as @code{from}, @code{to}, and @code{do})
369 in those positions in the macro call.
371 Here's an equivalent definition simplified through use of backquote:
375 (defmacro for (var from init to final do &rest body)
376 "Execute a simple \"for\" loop.
377 For example, (for i from 1 to 10 do (print i))."
379 (while (<= ,var ,final)
385 Both forms of this definition (with backquote and without) suffer from
386 the defect that @var{final} is evaluated on every iteration. If
387 @var{final} is a constant, this is not a problem. If it is a more
388 complex form, say @code{(long-complex-calculation x)}, this can slow
389 down the execution significantly. If @var{final} has side effects,
390 executing it more than once is probably incorrect.
392 @cindex macro argument evaluation
393 A well-designed macro definition takes steps to avoid this problem by
394 producing an expansion that evaluates the argument expressions exactly
395 once unless repeated evaluation is part of the intended purpose of the
396 macro. Here is a correct expansion for the @code{for} macro:
403 (setq square (* i i))
404 (princ (format "%d %d" i square))
409 Here is a macro definition that creates this expansion:
413 (defmacro for (var from init to final do &rest body)
414 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
423 Unfortunately, this fix introduces another problem,
424 described in the following section.
426 @node Surprising Local Vars
427 @subsection Local Variables in Macro Expansions
430 In the previous section, the definition of @code{for} was fixed as
431 follows to make the expansion evaluate the macro arguments the proper
436 (defmacro for (var from init to final do &rest body)
437 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
449 The new definition of @code{for} has a new problem: it introduces a
450 local variable named @code{max} which the user does not expect. This
451 causes trouble in examples such as the following:
456 (for x from 0 to 10 do
457 (let ((this (frob x)))
464 The references to @code{max} inside the body of the @code{for}, which
465 are supposed to refer to the user's binding of @code{max}, really access
466 the binding made by @code{for}.
468 The way to correct this is to use an uninterned symbol instead of
469 @code{max} (@pxref{Creating Symbols}). The uninterned symbol can be
470 bound and referred to just like any other symbol, but since it is
471 created by @code{for}, we know that it cannot already appear in the
472 user's program. Since it is not interned, there is no way the user can
473 put it into the program later. It will never appear anywhere except
474 where put by @code{for}. Here is a definition of @code{for} that works
479 (defmacro for (var from init to final do &rest body)
480 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
481 (let ((tempvar (make-symbol "max")))
484 (while (<= ,var ,tempvar)
491 This creates an uninterned symbol named @code{max} and puts it in the
492 expansion instead of the usual interned symbol @code{max} that appears
493 in expressions ordinarily.
495 @node Eval During Expansion
496 @subsection Evaluating Macro Arguments in Expansion
498 Another problem can happen if the macro definition itself
499 evaluates any of the macro argument expressions, such as by calling
500 @code{eval} (@pxref{Eval}). If the argument is supposed to refer to the
501 user's variables, you may have trouble if the user happens to use a
502 variable with the same name as one of the macro arguments. Inside the
503 macro body, the macro argument binding is the most local binding of this
504 variable, so any references inside the form being evaluated do refer to
505 it. Here is an example:
510 (list 'setq (eval a) t))
514 (foo x) @expansion{} (setq b t)
515 @result{} t ; @r{and @code{b} has been set.}
518 (foo a) @expansion{} (setq a t)
519 @result{} t ; @r{but this set @code{a}, not @code{c}.}
524 It makes a difference whether the user's variable is named @code{a} or
525 @code{x}, because @code{a} conflicts with the macro argument variable
528 Another problem with calling @code{eval} in a macro definition is that
529 it probably won't do what you intend in a compiled program. The
530 byte compiler runs macro definitions while compiling the program, when
531 the program's own computations (which you might have wished to access
532 with @code{eval}) don't occur and its local variable bindings don't
535 To avoid these problems, @strong{don't evaluate an argument expression
536 while computing the macro expansion}. Instead, substitute the
537 expression into the macro expansion, so that its value will be computed
538 as part of executing the expansion. This is how the other examples in
541 @node Repeated Expansion
542 @subsection How Many Times is the Macro Expanded?
544 Occasionally problems result from the fact that a macro call is
545 expanded each time it is evaluated in an interpreted function, but is
546 expanded only once (during compilation) for a compiled function. If the
547 macro definition has side effects, they will work differently depending
548 on how many times the macro is expanded.
550 Therefore, you should avoid side effects in computation of the
551 macro expansion, unless you really know what you are doing.
553 One special kind of side effect can't be avoided: constructing Lisp
554 objects. Almost all macro expansions include constructed lists; that is
555 the whole point of most macros. This is usually safe; there is just one
556 case where you must be careful: when the object you construct is part of a
557 quoted constant in the macro expansion.
559 If the macro is expanded just once, in compilation, then the object is
560 constructed just once, during compilation. But in interpreted
561 execution, the macro is expanded each time the macro call runs, and this
562 means a new object is constructed each time.
564 In most clean Lisp code, this difference won't matter. It can matter
565 only if you perform side-effects on the objects constructed by the macro
566 definition. Thus, to avoid trouble, @strong{avoid side effects on
567 objects constructed by macro definitions}. Here is an example of how
568 such side effects can get you into trouble:
572 (defmacro empty-object ()
573 (list 'quote (cons nil nil)))
577 (defun initialize (condition)
578 (let ((object (empty-object)))
580 (setcar object condition))
586 If @code{initialize} is interpreted, a new list @code{(nil)} is
587 constructed each time @code{initialize} is called. Thus, no side effect
588 survives between calls. If @code{initialize} is compiled, then the
589 macro @code{empty-object} is expanded during compilation, producing a
590 single ``constant'' @code{(nil)} that is reused and altered each time
591 @code{initialize} is called.
593 One way to avoid pathological cases like this is to think of
594 @code{empty-object} as a funny kind of constant, not as a memory
595 allocation construct. You wouldn't use @code{setcar} on a constant such
596 as @code{'(nil)}, so naturally you won't use it on @code{(empty-object)}
599 @node Indenting Macros
600 @section Indenting Macros
602 Within a macro definition, you can use the @code{declare} form
603 (@pxref{Defining Macros}) to specify how @key{TAB} should indent
604 calls to the macro. An indentation specification is written like this:
607 (declare (indent @var{indent-spec}))
611 Here are the possibilities for @var{indent-spec}:
615 This is the same as no property---use the standard indentation pattern.
617 Handle this function like a @samp{def} construct: treat the second
618 line as the start of a @dfn{body}.
619 @item an integer, @var{number}
620 The first @var{number} arguments of the function are
621 @dfn{distinguished} arguments; the rest are considered the body
622 of the expression. A line in the expression is indented according to
623 whether the first argument on it is distinguished or not. If the
624 argument is part of the body, the line is indented @code{lisp-body-indent}
625 more columns than the open-parenthesis starting the containing
626 expression. If the argument is distinguished and is either the first
627 or second argument, it is indented @emph{twice} that many extra columns.
628 If the argument is distinguished and not the first or second argument,
629 the line uses the standard pattern.
630 @item a symbol, @var{symbol}
631 @var{symbol} should be a function name; that function is called to
632 calculate the indentation of a line within this expression. The
633 function receives two arguments:
637 The value returned by @code{parse-partial-sexp} (a Lisp primitive for
638 indentation and nesting computation) when it parses up to the
639 beginning of this line.
641 The position at which the line being indented begins.
645 It should return either a number, which is the number of columns of
646 indentation for that line, or a list whose car is such a number. The
647 difference between returning a number and returning a list is that a
648 number says that all following lines at the same nesting level should
649 be indented just like this one; a list says that following lines might
650 call for different indentations. This makes a difference when the
651 indentation is being computed by @kbd{C-M-q}; if the value is a
652 number, @kbd{C-M-q} need not recalculate indentation for the following
653 lines until the end of the list.