2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990-1995, 1998, 2001-2018 Free Software Foundation,
5 @c See the file elisp.texi for copying conditions.
10 @dfn{Macros} enable you to define new control constructs and other
11 language features. A macro is defined much like a function, but instead
12 of telling how to compute a value, it tells how to compute another Lisp
13 expression which will in turn compute the value. We call this
14 expression the @dfn{expansion} of the macro.
16 Macros can do this because they operate on the unevaluated expressions
17 for the arguments, not on the argument values as functions do. They can
18 therefore construct an expansion containing these argument expressions
21 If you are using a macro to do something an ordinary function could
22 do, just for the sake of speed, consider using an inline function
23 instead. @xref{Inline Functions}.
26 * Simple Macro:: A basic example.
27 * Expansion:: How, when and why macros are expanded.
28 * Compiling Macros:: How macros are expanded by the compiler.
29 * Defining Macros:: How to write a macro definition.
30 * Problems with Macros:: Don't evaluate the macro arguments too many times.
31 Don't hide the user's variables.
32 * Indenting Macros:: Specifying how to indent macro calls.
36 @section A Simple Example of a Macro
38 Suppose we would like to define a Lisp construct to increment a
39 variable value, much like the @code{++} operator in C@. We would like to
40 write @code{(inc x)} and have the effect of @code{(setq x (1+ x))}.
41 Here's a macro definition that does the job:
47 (list 'setq var (list '1+ var)))
51 When this is called with @code{(inc x)}, the argument @var{var} is the
52 symbol @code{x}---@emph{not} the @emph{value} of @code{x}, as it would
53 be in a function. The body of the macro uses this to construct the
54 expansion, which is @code{(setq x (1+ x))}. Once the macro definition
55 returns this expansion, Lisp proceeds to evaluate it, thus incrementing
59 This predicate tests whether its argument is a macro, and returns
60 @code{t} if so, @code{nil} otherwise.
64 @section Expansion of a Macro Call
65 @cindex expansion of macros
68 A macro call looks just like a function call in that it is a list which
69 starts with the name of the macro. The rest of the elements of the list
70 are the arguments of the macro.
72 Evaluation of the macro call begins like evaluation of a function call
73 except for one crucial difference: the macro arguments are the actual
74 expressions appearing in the macro call. They are not evaluated before
75 they are given to the macro definition. By contrast, the arguments of a
76 function are results of evaluating the elements of the function call
79 Having obtained the arguments, Lisp invokes the macro definition just
80 as a function is invoked. The argument variables of the macro are bound
81 to the argument values from the macro call, or to a list of them in the
82 case of a @code{&rest} argument. And the macro body executes and
83 returns its value just as a function body does.
85 The second crucial difference between macros and functions is that
86 the value returned by the macro body is an alternate Lisp expression,
87 also known as the @dfn{expansion} of the macro. The Lisp interpreter
88 proceeds to evaluate the expansion as soon as it comes back from the
91 Since the expansion is evaluated in the normal manner, it may contain
92 calls to other macros. It may even be a call to the same macro, though
95 Note that Emacs tries to expand macros when loading an uncompiled
96 Lisp file. This is not always possible, but if it is, it speeds up
97 subsequent execution. @xref{How Programs Do Loading}.
99 You can see the expansion of a given macro call by calling
102 @defun macroexpand form &optional environment
103 @cindex macro expansion
104 This function expands @var{form}, if it is a macro call. If the result
105 is another macro call, it is expanded in turn, until something which is
106 not a macro call results. That is the value returned by
107 @code{macroexpand}. If @var{form} is not a macro call to begin with, it
108 is returned as given.
110 Note that @code{macroexpand} does not look at the subexpressions of
111 @var{form} (although some macro definitions may do so). Even if they
112 are macro calls themselves, @code{macroexpand} does not expand them.
114 The function @code{macroexpand} does not expand calls to inline functions.
115 Normally there is no need for that, since a call to an inline function is
116 no harder to understand than a call to an ordinary function.
118 If @var{environment} is provided, it specifies an alist of macro
119 definitions that shadow the currently defined macros. Byte compilation
125 (list 'setq var (list '1+ var)))
129 (macroexpand '(inc r))
130 @result{} (setq r (1+ r))
134 (defmacro inc2 (var1 var2)
135 (list 'progn (list 'inc var1) (list 'inc var2)))
139 (macroexpand '(inc2 r s))
140 @result{} (progn (inc r) (inc s)) ; @r{@code{inc} not expanded here.}
146 @defun macroexpand-all form &optional environment
147 @code{macroexpand-all} expands macros like @code{macroexpand}, but
148 will look for and expand all macros in @var{form}, not just at the
149 top-level. If no macros are expanded, the return value is @code{eq}
152 Repeating the example used for @code{macroexpand} above with
153 @code{macroexpand-all}, we see that @code{macroexpand-all} @emph{does}
154 expand the embedded calls to @code{inc}:
157 (macroexpand-all '(inc2 r s))
158 @result{} (progn (setq r (1+ r)) (setq s (1+ s)))
163 @defun macroexpand-1 form &optional environment
164 This function expands macros like @code{macroexpand}, but it only
165 performs one step of the expansion: if the result is another macro
166 call, @code{macroexpand-1} will not expand it.
169 @node Compiling Macros
170 @section Macros and Byte Compilation
171 @cindex byte-compiling macros
173 You might ask why we take the trouble to compute an expansion for a
174 macro and then evaluate the expansion. Why not have the macro body
175 produce the desired results directly? The reason has to do with
178 When a macro call appears in a Lisp program being compiled, the Lisp
179 compiler calls the macro definition just as the interpreter would, and
180 receives an expansion. But instead of evaluating this expansion, it
181 compiles the expansion as if it had appeared directly in the program.
182 As a result, the compiled code produces the value and side effects
183 intended for the macro, but executes at full compiled speed. This would
184 not work if the macro body computed the value and side effects
185 itself---they would be computed at compile time, which is not useful.
187 In order for compilation of macro calls to work, the macros must
188 already be defined in Lisp when the calls to them are compiled. The
189 compiler has a special feature to help you do this: if a file being
190 compiled contains a @code{defmacro} form, the macro is defined
191 temporarily for the rest of the compilation of that file.
193 Byte-compiling a file also executes any @code{require} calls at
194 top-level in the file, so you can ensure that necessary macro
195 definitions are available during compilation by requiring the files
196 that define them (@pxref{Named Features}). To avoid loading the macro
197 definition files when someone @emph{runs} the compiled program, write
198 @code{eval-when-compile} around the @code{require} calls (@pxref{Eval
201 @node Defining Macros
202 @section Defining Macros
203 @cindex defining macros
204 @cindex macro, how to define
206 A Lisp macro object is a list whose @sc{car} is @code{macro}, and
207 whose @sc{cdr} is a function. Expansion of the macro works
208 by applying the function (with @code{apply}) to the list of
209 @emph{unevaluated} arguments from the macro call.
211 It is possible to use an anonymous Lisp macro just like an anonymous
212 function, but this is never done, because it does not make sense to
213 pass an anonymous macro to functionals such as @code{mapcar}. In
214 practice, all Lisp macros have names, and they are almost always
215 defined with the @code{defmacro} macro.
217 @defmac defmacro name args [doc] [declare] body@dots{}
218 @code{defmacro} defines the symbol @var{name} (which should not be
219 quoted) as a macro that looks like this:
222 (macro lambda @var{args} . @var{body})
225 (Note that the @sc{cdr} of this list is a lambda expression.) This
226 macro object is stored in the function cell of @var{name}. The
227 meaning of @var{args} is the same as in a function, and the keywords
228 @code{&rest} and @code{&optional} may be used (@pxref{Argument List}).
229 Neither @var{name} nor @var{args} should be quoted. The return value
230 of @code{defmacro} is undefined.
232 @var{doc}, if present, should be a string specifying the macro's
233 documentation string. @var{declare}, if present, should be a
234 @code{declare} form specifying metadata for the macro (@pxref{Declare
235 Form}). Note that macros cannot have interactive declarations, since
236 they cannot be called interactively.
239 Macros often need to construct large list structures from a mixture
240 of constants and nonconstant parts. To make this easier, use the
241 @samp{`} syntax (@pxref{Backquote}). For example:
246 (defmacro t-becomes-nil (variable)
247 `(if (eq ,variable t)
248 (setq ,variable nil)))
253 @equiv{} (if (eq foo t) (setq foo nil))
258 @node Problems with Macros
259 @section Common Problems Using Macros
260 @cindex macro caveats
262 Macro expansion can have counterintuitive consequences. This
263 section describes some important consequences that can lead to
264 trouble, and rules to follow to avoid trouble.
267 * Wrong Time:: Do the work in the expansion, not in the macro.
268 * Argument Evaluation:: The expansion should evaluate each macro arg once.
269 * Surprising Local Vars:: Local variable bindings in the expansion
270 require special care.
271 * Eval During Expansion:: Don't evaluate them; put them in the expansion.
272 * Repeated Expansion:: Avoid depending on how many times expansion is done.
276 @subsection Wrong Time
278 The most common problem in writing macros is doing some of the
279 real work prematurely---while expanding the macro, rather than in the
280 expansion itself. For instance, one real package had this macro
284 (defmacro my-set-buffer-multibyte (arg)
285 (if (fboundp 'set-buffer-multibyte)
286 (set-buffer-multibyte arg)))
289 With this erroneous macro definition, the program worked fine when
290 interpreted but failed when compiled. This macro definition called
291 @code{set-buffer-multibyte} during compilation, which was wrong, and
292 then did nothing when the compiled package was run. The definition
293 that the programmer really wanted was this:
296 (defmacro my-set-buffer-multibyte (arg)
297 (if (fboundp 'set-buffer-multibyte)
298 `(set-buffer-multibyte ,arg)))
302 This macro expands, if appropriate, into a call to
303 @code{set-buffer-multibyte} that will be executed when the compiled
304 program is actually run.
306 @node Argument Evaluation
307 @subsection Evaluating Macro Arguments Repeatedly
309 When defining a macro you must pay attention to the number of times
310 the arguments will be evaluated when the expansion is executed. The
311 following macro (used to facilitate iteration) illustrates the
312 problem. This macro allows us to write a for-loop construct.
317 (defmacro for (var from init to final do &rest body)
318 "Execute a simple \"for\" loop.
319 For example, (for i from 1 to 10 do (print i))."
320 (list 'let (list (list var init))
322 (cons (list '<= var final)
323 (append body (list (list 'inc var)))))))
327 (for i from 1 to 3 do
328 (setq square (* i i))
329 (princ (format "\n%d %d" i square)))
335 (setq square (* i i))
336 (princ (format "\n%d %d" i square))
349 The arguments @code{from}, @code{to}, and @code{do} in this macro are
350 syntactic sugar; they are entirely ignored. The idea is that you
351 will write noise words (such as @code{from}, @code{to}, and @code{do})
352 in those positions in the macro call.
354 Here's an equivalent definition simplified through use of backquote:
358 (defmacro for (var from init to final do &rest body)
359 "Execute a simple \"for\" loop.
360 For example, (for i from 1 to 10 do (print i))."
362 (while (<= ,var ,final)
368 Both forms of this definition (with backquote and without) suffer from
369 the defect that @var{final} is evaluated on every iteration. If
370 @var{final} is a constant, this is not a problem. If it is a more
371 complex form, say @code{(long-complex-calculation x)}, this can slow
372 down the execution significantly. If @var{final} has side effects,
373 executing it more than once is probably incorrect.
375 @cindex macro argument evaluation
376 A well-designed macro definition takes steps to avoid this problem by
377 producing an expansion that evaluates the argument expressions exactly
378 once unless repeated evaluation is part of the intended purpose of the
379 macro. Here is a correct expansion for the @code{for} macro:
386 (setq square (* i i))
387 (princ (format "%d %d" i square))
392 Here is a macro definition that creates this expansion:
396 (defmacro for (var from init to final do &rest body)
397 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
406 Unfortunately, this fix introduces another problem,
407 described in the following section.
409 @node Surprising Local Vars
410 @subsection Local Variables in Macro Expansions
413 In the previous section, the definition of @code{for} was fixed as
414 follows to make the expansion evaluate the macro arguments the proper
419 (defmacro for (var from init to final do &rest body)
420 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
432 The new definition of @code{for} has a new problem: it introduces a
433 local variable named @code{max} which the user does not expect. This
434 causes trouble in examples such as the following:
439 (for x from 0 to 10 do
440 (let ((this (frob x)))
447 The references to @code{max} inside the body of the @code{for}, which
448 are supposed to refer to the user's binding of @code{max}, really access
449 the binding made by @code{for}.
451 The way to correct this is to use an uninterned symbol instead of
452 @code{max} (@pxref{Creating Symbols}). The uninterned symbol can be
453 bound and referred to just like any other symbol, but since it is
454 created by @code{for}, we know that it cannot already appear in the
455 user's program. Since it is not interned, there is no way the user can
456 put it into the program later. It will never appear anywhere except
457 where put by @code{for}. Here is a definition of @code{for} that works
462 (defmacro for (var from init to final do &rest body)
463 "Execute a simple for loop: (for i from 1 to 10 do (print i))."
464 (let ((tempvar (make-symbol "max")))
467 (while (<= ,var ,tempvar)
474 This creates an uninterned symbol named @code{max} and puts it in the
475 expansion instead of the usual interned symbol @code{max} that appears
476 in expressions ordinarily.
478 @node Eval During Expansion
479 @subsection Evaluating Macro Arguments in Expansion
481 Another problem can happen if the macro definition itself
482 evaluates any of the macro argument expressions, such as by calling
483 @code{eval} (@pxref{Eval}). If the argument is supposed to refer to the
484 user's variables, you may have trouble if the user happens to use a
485 variable with the same name as one of the macro arguments. Inside the
486 macro body, the macro argument binding is the most local binding of this
487 variable, so any references inside the form being evaluated do refer to
488 it. Here is an example:
493 (list 'setq (eval a) t))
497 (foo x) @expansion{} (setq b t)
498 @result{} t ; @r{and @code{b} has been set.}
501 (foo a) @expansion{} (setq a t)
502 @result{} t ; @r{but this set @code{a}, not @code{c}.}
507 It makes a difference whether the user's variable is named @code{a} or
508 @code{x}, because @code{a} conflicts with the macro argument variable
511 Another problem with calling @code{eval} in a macro definition is that
512 it probably won't do what you intend in a compiled program. The
513 byte compiler runs macro definitions while compiling the program, when
514 the program's own computations (which you might have wished to access
515 with @code{eval}) don't occur and its local variable bindings don't
518 To avoid these problems, @strong{don't evaluate an argument expression
519 while computing the macro expansion}. Instead, substitute the
520 expression into the macro expansion, so that its value will be computed
521 as part of executing the expansion. This is how the other examples in
524 @node Repeated Expansion
525 @subsection How Many Times is the Macro Expanded?
527 Occasionally problems result from the fact that a macro call is
528 expanded each time it is evaluated in an interpreted function, but is
529 expanded only once (during compilation) for a compiled function. If the
530 macro definition has side effects, they will work differently depending
531 on how many times the macro is expanded.
533 Therefore, you should avoid side effects in computation of the
534 macro expansion, unless you really know what you are doing.
536 One special kind of side effect can't be avoided: constructing Lisp
537 objects. Almost all macro expansions include constructed lists; that is
538 the whole point of most macros. This is usually safe; there is just one
539 case where you must be careful: when the object you construct is part of a
540 quoted constant in the macro expansion.
542 If the macro is expanded just once, in compilation, then the object is
543 constructed just once, during compilation. But in interpreted
544 execution, the macro is expanded each time the macro call runs, and this
545 means a new object is constructed each time.
547 In most clean Lisp code, this difference won't matter. It can matter
548 only if you perform side-effects on the objects constructed by the macro
549 definition. Thus, to avoid trouble, @strong{avoid side effects on
550 objects constructed by macro definitions}. Here is an example of how
551 such side effects can get you into trouble:
555 (defmacro empty-object ()
556 (list 'quote (cons nil nil)))
560 (defun initialize (condition)
561 (let ((object (empty-object)))
563 (setcar object condition))
569 If @code{initialize} is interpreted, a new list @code{(nil)} is
570 constructed each time @code{initialize} is called. Thus, no side effect
571 survives between calls. If @code{initialize} is compiled, then the
572 macro @code{empty-object} is expanded during compilation, producing a
573 single constant @code{(nil)} that is reused and altered each time
574 @code{initialize} is called.
576 One way to avoid pathological cases like this is to think of
577 @code{empty-object} as a funny kind of constant, not as a memory
578 allocation construct. You wouldn't use @code{setcar} on a constant such
579 as @code{'(nil)}, so naturally you won't use it on @code{(empty-object)}
582 @node Indenting Macros
583 @section Indenting Macros
585 Within a macro definition, you can use the @code{declare} form
586 (@pxref{Defining Macros}) to specify how @key{TAB} should indent
587 calls to the macro. An indentation specification is written like this:
590 (declare (indent @var{indent-spec}))
594 @cindex @code{lisp-indent-function} property
595 This results in the @code{lisp-indent-function} property being set on
599 Here are the possibilities for @var{indent-spec}:
603 This is the same as no property---use the standard indentation pattern.
605 Handle this function like a @samp{def} construct: treat the second
606 line as the start of a @dfn{body}.
607 @item an integer, @var{number}
608 The first @var{number} arguments of the function are
609 @dfn{distinguished} arguments; the rest are considered the body
610 of the expression. A line in the expression is indented according to
611 whether the first argument on it is distinguished or not. If the
612 argument is part of the body, the line is indented @code{lisp-body-indent}
613 more columns than the open-parenthesis starting the containing
614 expression. If the argument is distinguished and is either the first
615 or second argument, it is indented @emph{twice} that many extra columns.
616 If the argument is distinguished and not the first or second argument,
617 the line uses the standard pattern.
618 @item a symbol, @var{symbol}
619 @var{symbol} should be a function name; that function is called to
620 calculate the indentation of a line within this expression. The
621 function receives two arguments:
625 The position at which the line being indented begins.
627 The value returned by @code{parse-partial-sexp} (a Lisp primitive for
628 indentation and nesting computation) when it parses up to the
629 beginning of this line.
633 It should return either a number, which is the number of columns of
634 indentation for that line, or a list whose car is such a number. The
635 difference between returning a number and returning a list is that a
636 number says that all following lines at the same nesting level should
637 be indented just like this one; a list says that following lines might
638 call for different indentations. This makes a difference when the
639 indentation is being computed by @kbd{C-M-q}; if the value is a
640 number, @kbd{C-M-q} need not recalculate indentation for the following
641 lines until the end of the list.