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 section Argument Lists.
Destructuring is made available to the user by way of the following macro:
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.
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:
(define-compiler-macro member* (&whole form a list &rest keys)
(if (and (null keys)
(eq (car-safe a) 'quote)
(not (floatp-safe (cadr a))))
(list 'memq a list)
form))
This definition causes (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
member* call is left intact. (The actual compiler macro
for member* optimizes a number of other cases, including
common :test predicates.)
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 section Macro Bindings, for descriptions of the macrolet
and symbol-macrolet forms for making "local" macro
definitions.
Go to the first, previous, next, last section, table of contents.