Macros
******

Macros enable you to define new control constructs and other language features.  A macro is defined much like a function, but instead of telling how to compute a value, it tells how to compute another Lisp expression which will in turn compute the value.  We call this expression the expansion of the macro.

Macros can do this because they operate on the unevaluated expressions for the arguments, not on the argument values as functions do.  They can therefore construct an expansion containing these argument expressions or parts of them.

If you are using a macro to do something an ordinary function could do, just for the sake of speed, consider using an inline function instead.  See Inline Functions.

A Simple Example of a Macro
===========================

Suppose we would like to define a Lisp construct to increment a variable value, much like the ++ operator in C.  We would like to write (inc x) and have the effect of (setq x (1+ x)). Here's a macro definition that does the job:

     (defmacro inc (var)
        (list 'setq var (list '1+ var)))

When this is called with (inc x), the argument VAR is the symbol x---not the value of x, as it would be in a function.  The body of the macro uses this to construct the expansion, which is (setq x (1+ x)).  Once the macro definition returns this expansion, Lisp proceeds to evaluate it, thus incrementing x.

Expansion of a Macro Call
=========================

A macro call looks just like a function call in that it is a list which starts with the name of the macro.  The rest of the elements of the list are the arguments of the macro.

Evaluation of the macro call begins like evaluation of a function call except for one crucial difference: the macro arguments are the actual expressions appearing in the macro call.  They are not evaluated before they are given to the macro definition.  By contrast, the arguments of a function are results of evaluating the elements of the function call list.

Having obtained the arguments, Lisp invokes the macro definition just as a function is invoked.  The argument variables of the macro are bound to the argument values from the macro call, or to a list of them in the case of a &rest argument.  And the macro body executes and returns its value just as a function body does.

The second crucial difference between macros and functions is that the value returned by the macro body is an alternate Lisp expression, also known as the expansion of the macro.  The Lisp interpreter proceeds to evaluate the expansion as soon as it comes back from the macro.

Since the expansion is evaluated in the normal manner, it may contain calls to other macros.  It may even be a call to the same macro, though this is unusual.

Note that Emacs tries to expand macros when loading an uncompiled Lisp file.  This is not always possible, but if it is, it speeds up subsequent execution.  See How Programs Do Loading.

You can see the expansion of a given macro call by calling macroexpand.

 -- Function: macroexpand form &optional environment
     This function expands FORM, if it is a macro call.  If the result is another macro call, it is expanded in turn, until something which is not a macro call results.  That is the value returned by macroexpand.  If FORM is not a macro call to begin with, it is returned as given.

     Note that macroexpand does not look at the subexpressions of FORM (although some macro definitions may do so).  Even if they are macro calls themselves, macroexpand does not expand them.

     The function macroexpand does not expand calls to inline functions. Normally there is no need for that, since a call to an inline function is no harder to understand than a call to an ordinary function.

     If ENVIRONMENT is provided, it specifies an alist of macro definitions that shadow the currently defined macros.  Byte compilation uses this feature.

          (defmacro inc (var)
              (list 'setq var (list '1+ var)))

          (macroexpand '(inc r))
               => (setq r (1+ r))

          (defmacro inc2 (var1 var2)
              (list 'progn (list 'inc var1) (list 'inc var2)))

          (macroexpand '(inc2 r s))
               => (progn (inc r) (inc s))  ; inc not expanded here.

 -- Function: macroexpand-all form &optional environment
     macroexpand-all expands macros like macroexpand, but will look for and expand all macros in FORM, not just at the top-level.  If no macros are expanded, the return value is eq to FORM.

     Repeating the example used for macroexpand above with macroexpand-all, we see that macroexpand-all does expand the embedded calls to inc:

          (macroexpand-all '(inc2 r s))
               => (progn (setq r (1+ r)) (setq s (1+ s)))

Macros and Byte Compilation
===========================

You might ask why we take the trouble to compute an expansion for a macro and then evaluate the expansion.  Why not have the macro body produce the desired results directly?  The reason has to do with compilation.

When a macro call appears in a Lisp program being compiled, the Lisp compiler calls the macro definition just as the interpreter would, and receives an expansion.  But instead of evaluating this expansion, it compiles the expansion as if it had appeared directly in the program. As a result, the compiled code produces the value and side effects intended for the macro, but executes at full compiled speed.  This would not work if the macro body computed the value and side effects itself---they would be computed at compile time, which is not useful.

In order for compilation of macro calls to work, the macros must already be defined in Lisp when the calls to them are compiled.  The compiler has a special feature to help you do this: if a file being compiled contains a defmacro form, the macro is defined temporarily for the rest of the compilation of that file.

Byte-compiling a file also executes any require calls at top-level in the file, so you can ensure that necessary macro definitions are available during compilation by requiring the files that define them (see Named Features).  To avoid loading the macro definition files when someone runs the compiled program, write eval-when-compile around the require calls (see Eval During Compile).

Defining Macros
===============

A Lisp macro object is a list whose CAR is macro, and whose CDR is a lambda expression.  Expansion of the macro works by applying the lambda expression (with apply) to the list of unevaluated arguments from the macro call.

It is possible to use an anonymous Lisp macro just like an anonymous function, but this is never done, because it does not make sense to pass an anonymous macro to functionals such as mapcar.  In practice, all Lisp macros have names, and they are almost always defined with the defmacro macro.

 -- Macro: defmacro name args [doc] [declare] body...
     defmacro defines the symbol NAME (which should not be quoted) as a macro that looks like this:

          (macro lambda ARGS . BODY)

     (Note that the CDR of this list is a lambda expression.)  This macro object is stored in the function cell of NAME.  The meaning of ARGS is the same as in a function, and the keywords &rest and &optional may be used (see Argument List). Neither NAME nor ARGS should be quoted.  The return value of defmacro is undefined.

     DOC, if present, should be a string specifying the macro's documentation string.  DECLARE, if present, should be a declare form specifying metadata for the macro (see Declare Form).  Note that macros cannot have interactive declarations, since they cannot be called interactively.

Macros often need to construct large list structures from a mixture of constants and nonconstant parts.  To make this easier, use the ` syntax (see Backquote).  For example:

          (defmacro t-becomes-nil (variable)
            `(if (eq ,variable t)
                 (setq ,variable nil)))

          (t-becomes-nil foo)
               == (if (eq foo t) (setq foo nil))

The body of a macro definition can include a declare form, which specifies additional properties about the macro.  See Declare Form.

Common Problems Using Macros
============================

Macro expansion can have counterintuitive consequences.  This section describes some important consequences that can lead to trouble, and rules to follow to avoid trouble.

Wrong Time
----------

The most common problem in writing macros is doing some of the real work prematurely---while expanding the macro, rather than in the expansion itself.  For instance, one real package had this macro definition:

     (defmacro my-set-buffer-multibyte (arg)
       (if (fboundp 'set-buffer-multibyte)
           (set-buffer-multibyte arg)))

With this erroneous macro definition, the program worked fine when interpreted but failed when compiled.  This macro definition called set-buffer-multibyte during compilation, which was wrong, and then did nothing when the compiled package was run.  The definition that the programmer really wanted was this:

     (defmacro my-set-buffer-multibyte (arg)
       (if (fboundp 'set-buffer-multibyte)
           `(set-buffer-multibyte ,arg)))

This macro expands, if appropriate, into a call to set-buffer-multibyte that will be executed when the compiled program is actually run.

Evaluating Macro Arguments Repeatedly
-------------------------------------

When defining a macro you must pay attention to the number of times the arguments will be evaluated when the expansion is executed.  The following macro (used to facilitate iteration) illustrates the problem.  This macro allows us to write a ``for'' loop construct.

     (defmacro for (var from init to final do &rest body)
       "Execute a simple \"for\" loop.
     For example, (for i from 1 to 10 do (print i))."
       (list 'let (list (list var init))
             (cons 'while
                   (cons (list '<= var final)
                         (append body (list (list 'inc var)))))))

     (for i from 1 to 3 do
        (setq square (* i i))
        (princ (format "\n%d %d" i square)))
     ==>

     (let ((i 1))
       (while (<= i 3)
         (setq square (* i i))
         (princ (format "\n%d %d" i square))
         (inc i)))

          -|1       1
          -|2       4
          -|3       9
     => nil

The arguments from, to, and do in this macro are ``syntactic sugar''; they are entirely ignored.  The idea is that you will write noise words (such as from, to, and do) in those positions in the macro call.

Here's an equivalent definition simplified through use of backquote:

     (defmacro for (var from init to final do &rest body)
       "Execute a simple \"for\" loop.
     For example, (for i from 1 to 10 do (print i))."
       `(let ((,var ,init))
          (while (<= ,var ,final)
            ,@body
            (inc ,var))))

Both forms of this definition (with backquote and without) suffer from the defect that FINAL is evaluated on every iteration.  If FINAL is a constant, this is not a problem.  If it is a more complex form, say (long-complex-calculation x), this can slow down the execution significantly.  If FINAL has side effects, executing it more than once is probably incorrect.

A well-designed macro definition takes steps to avoid this problem by producing an expansion that evaluates the argument expressions exactly once unless repeated evaluation is part of the intended purpose of the macro.  Here is a correct expansion for the for macro:

     (let ((i 1)
           (max 3))
       (while (<= i max)
         (setq square (* i i))
         (princ (format "%d      %d" i square))
         (inc i)))

Here is a macro definition that creates this expansion:

     (defmacro for (var from init to final do &rest body)
       "Execute a simple for loop: (for i from 1 to 10 do (print i))."
       `(let ((,var ,init)
              (max ,final))
          (while (<= ,var max)
            ,@body
            (inc ,var))))

Unfortunately, this fix introduces another problem, described in the following section.

Local Variables in Macro Expansions
-----------------------------------

In the previous section, the definition of for was fixed as follows to make the expansion evaluate the macro arguments the proper number of times:

     (defmacro for (var from init to final do &rest body)
       "Execute a simple for loop: (for i from 1 to 10 do (print i))."

       `(let ((,var ,init)
              (max ,final))
          (while (<= ,var max)
            ,@body
            (inc ,var))))

The new definition of for has a new problem: it introduces a local variable named max which the user does not expect.  This causes trouble in examples such as the following:

     (let ((max 0))
       (for x from 0 to 10 do
         (let ((this (frob x)))
           (if (< max this)
               (setq max this)))))

The references to max inside the body of the for, which are supposed to refer to the user's binding of max, really access the binding made by for.

The way to correct this is to use an uninterned symbol instead of max (see Creating Symbols).  The uninterned symbol can be bound and referred to just like any other symbol, but since it is created by for, we know that it cannot already appear in the user's program.  Since it is not interned, there is no way the user can put it into the program later.  It will never appear anywhere except where put by for.  Here is a definition of for that works this way:

     (defmacro for (var from init to final do &rest body)
       "Execute a simple for loop: (for i from 1 to 10 do (print i))."
       (let ((tempvar (make-symbol "max")))
         `(let ((,var ,init)
                (,tempvar ,final))
            (while (<= ,var ,tempvar)
              ,@body
              (inc ,var)))))

This creates an uninterned symbol named max and puts it in the expansion instead of the usual interned symbol max that appears in expressions ordinarily.

Evaluating Macro Arguments in Expansion
---------------------------------------

Another problem can happen if the macro definition itself evaluates any of the macro argument expressions, such as by calling eval (see Eval).  If the argument is supposed to refer to the user's variables, you may have trouble if the user happens to use a variable with the same name as one of the macro arguments.  Inside the macro body, the macro argument binding is the most local binding of this variable, so any references inside the form being evaluated do refer to it.  Here is an example:

     (defmacro foo (a)
       (list 'setq (eval a) t))

     (setq x 'b)
     (foo x) ==> (setq b t)
          => t                  ; and b has been set.
     ;; but
     (setq a 'c)
     (foo a) ==> (setq a t)
          => t                  ; but this set a, not c.

It makes a difference whether the user's variable is named a or x, because a conflicts with the macro argument variable a.

Another problem with calling eval in a macro definition is that it probably won't do what you intend in a compiled program.  The byte compiler runs macro definitions while compiling the program, when the program's own computations (which you might have wished to access with eval) don't occur and its local variable bindings don't exist.

To avoid these problems, don't evaluate an argument expression while computing the macro expansion.  Instead, substitute the expression into the macro expansion, so that its value will be computed as part of executing the expansion.  This is how the other examples in this chapter work.

How Many Times is the Macro Expanded?
-------------------------------------

Occasionally problems result from the fact that a macro call is expanded each time it is evaluated in an interpreted function, but is expanded only once (during compilation) for a compiled function.  If the macro definition has side effects, they will work differently depending on how many times the macro is expanded.

Therefore, you should avoid side effects in computation of the macro expansion, unless you really know what you are doing.

One special kind of side effect can't be avoided: constructing Lisp objects.  Almost all macro expansions include constructed lists; that is the whole point of most macros.  This is usually safe; there is just one case where you must be careful: when the object you construct is part of a quoted constant in the macro expansion.

If the macro is expanded just once, in compilation, then the object is constructed just once, during compilation.  But in interpreted execution, the macro is expanded each time the macro call runs, and this means a new object is constructed each time.

In most clean Lisp code, this difference won't matter.  It can matter only if you perform side-effects on the objects constructed by the macro definition.  Thus, to avoid trouble, avoid side effects on objects constructed by macro definitions.  Here is an example of how such side effects can get you into trouble:

     (defmacro empty-object ()
       (list 'quote (cons nil nil)))

     (defun initialize (condition)
       (let ((object (empty-object)))
         (if condition
             (setcar object condition))
         object))

If initialize is interpreted, a new list (nil) is constructed each time initialize is called.  Thus, no side effect survives between calls.  If initialize is compiled, then the macro empty-object is expanded during compilation, producing a single ``constant'' (nil) that is reused and altered each time initialize is called.

One way to avoid pathological cases like this is to think of empty-object as a funny kind of constant, not as a memory allocation construct.  You wouldn't use setcar on a constant such as '(nil), so naturally you won't use it on (empty-object) either.

Indenting Macros
================

Within a macro definition, you can use the declare form (see Defining Macros) to specify how TAB should indent calls to the macro.  An indentation specification is written like this:

     (declare (indent INDENT-SPEC))

Here are the possibilities for INDENT-SPEC:

nil
     This is the same as no property---use the standard indentation pattern.

defun
     Handle this function like a def construct: treat the second line as the start of a body.

an integer, NUMBER
     The first NUMBER arguments of the function are distinguished arguments; the rest are considered the body of the expression.  A line in the expression is indented according to whether the first argument on it is distinguished or not.  If the argument is part of the body, the line is indented lisp-body-indent more columns than the open-parenthesis starting the containing expression.  If the argument is distinguished and is either the first or second argument, it is indented twice that many extra columns. If the argument is distinguished and not the first or second argument, the line uses the standard pattern.

a symbol, SYMBOL
     SYMBOL should be a function name; that function is called to calculate the indentation of a line within this expression.  The function receives two arguments:

     STATE
          The value returned by parse-partial-sexp (a Lisp primitive for indentation and nesting computation) when it parses up to the beginning of this line.

     POS
          The position at which the line being indented begins.

     It should return either a number, which is the number of columns of indentation for that line, or a list whose car is such a number.  The difference between returning a number and returning a list is that a number says that all following lines at the same nesting level should be indented just like this one; a list says that following lines might call for different indentations.  This makes a difference when the indentation is being computed by C-M-q; if the value is a number, C-M-q need not recalculate indentation for the following lines until the end of the list.