Macros in LISP

In LISP, a macro is a code transformer that runs at macro-expansion time, taking unevaluated source forms as arguments and returning new source code to be evaluated in their place. Unlike a function, which receives already-computed values, a macro receives the literal list structure the programmer wrote and can rewrite it before the compiler evaluates anything. This works because LISP source code is itself built from the same list data structures the language manipulates at runtime, so a macro is a function from code to code.

The standard way to define a macro in Common Lisp is defmacro, whose body typically uses backquote (quasiquote) to construct the replacement code, with commas to splice in the macro's arguments. For example, an unless macro rewrites (unless test body) into (if (not test) body) — the macro never evaluates test itself; it only assembles a new if form containing the caller's original, still-unevaluated test expression. This lets programmers add control-flow constructs that don't exist as built-in special forms.

Because macro expansion happens before evaluation, LISP provides macroexpand-1 and macroexpand to let programmers inspect exactly what code a macro call produces without running it. macroexpand-1 performs a single expansion step, useful for macros built on top of other macros, while macroexpand expands repeatedly until the result is no longer a macro call. This tooling is essential because a subtly wrong macro can silently generate broken or inefficient code that only surfaces as a confusing runtime error far from the macro definition.

A naive macro can accidentally 'capture' a variable: if the macro's expansion introduces a symbol like temp that collides with a variable the caller already uses, the caller's variable gets silently shadowed or overwritten. Common Lisp programmers avoid this with gensym, which generates a fresh, guaranteed-unique symbol for each expansion, while Scheme's syntax-rules and syntax-case provide hygienic macros that rename introduced identifiers automatically. Anaphoric macros deliberately break hygiene on purpose, for example binding a symbol named it so the caller can refer to a computed value, but this should be an explicit, documented design choice, not an accident.