5 Macros

This package implements the various Common Lisp features of defmacro, such as destructuring, &environment, and &body. Top-level &whole is not implemented for defmacro due to technical difficulties. See Argument Lists.

Destructuring is made available to the user by way of the following macro:

Macro: cl-destructuring-bind arglist expr forms… ¶

This macro expands to code that executes forms, with the variables in arglist bound to the list of values returned by expr. The arglist can include all the features allowed for cl-defmacro argument lists, including destructuring. (The &environment keyword is not allowed.) The macro expansion will signal an error if expr returns a list of the wrong number of arguments or with incorrect keyword arguments.

This package also includes the Common Lisp define-compiler-macro facility, which allows you to define compile-time expansions and optimizations for your functions.

Macro: cl-define-compiler-macro name arglist forms… ¶

This form is similar to defmacro, except that it only expands calls to name at compile-time; calls processed by the Lisp interpreter are not expanded, nor are they expanded by the macroexpand function.

The argument list may begin with a &whole keyword and a variable. This variable is bound to the macro-call form itself, i.e., to a list of the form ‘(name args…)’. If the macro expander returns this form unchanged, then the compiler treats it as a normal function call. This allows compiler macros to work as optimizers for special cases of a function, leaving complicated cases alone.

For example, here is a simplified version of a definition that appears as a standard part of this package:

(cl-define-compiler-macro cl-member (&whole form a list &rest keys)
     (if (and (null keys)
              (eq (car-safe a) 'quote)
              (not (floatp (cadr a))))
         (list 'memq a list)
       form))

This definition causes (cl-member a list) to change to a call to the faster memq in the common case where a is a non-floating-point constant; if a is anything else, or if there are any keyword arguments in the call, then the original cl-member call is left intact. (The actual compiler macro for cl-member optimizes a number of other cases, including common :test predicates.)

Function: cl-compiler-macroexpand form ¶

This function is analogous to macroexpand, except that it expands compiler macros rather than regular macros. It returns form unchanged if it is not a call to a function for which a compiler macro has been defined, or if that compiler macro decided to punt by returning its &whole argument. Like macroexpand, it expands repeatedly until it reaches a form for which no further expansion is possible.

See Macro Bindings, for descriptions of the cl-macrolet and cl-symbol-macrolet forms for making “local” macro definitions.