Gödel, Escher, Elisp: The Beauty of Macros

Emacs Lisp, commonly referred to as Elisp, is a programming language that boasts an intriguing feature: its code and data are interchangeable. This concept, known as homoiconicity, allows Elisp to treat programs and data as the same entity, represented as lists. One of the most captivating aspects of Elisp is its macro system, which harnesses this dualism between programs and data in numerous intriguing ways.

In this article, we'll delve into the beauty of macros, explore the concept of homoiconicity, and showcase their widespread use in Elisp.

Macros in Elisp are a powerful tool that leverage the language's homoiconic nature. They allow you to manipulate code as data, enabling the creation of powerful abstractions and metaprogramming constructs. To better understand macros, it's essential to grasp the concept of homoiconicity, which is a property of languages where programs and data share the same structure.

Homoiconicity, a term coined by Douglas Hofstadter, refers to the fact that a language's programs are written in the language's own data structures. In Elisp, this means that source code is comprised of lists, symbols, strings, and numbers. This unity of form between program and data is reminiscent of M.C. Escher's artwork, where the dualism of sides becomes a single continuous surface.

One of the most striking metaphors for this dualism is Escher's Möbius Strip II woodcut, where two sides appear to be separate but are actually one continuous surface. In Elisp, the program and data sides are intertwined, with any piece of code being just one character away from being a value you can inspect, transform, and rebuild. Similarly, any suitable value can be one function call away from becoming a program.

In Elisp, a macro is a special construct that operates at expansion time, before the program itself is executed. It receives code (the raw, unevaluated forms) and returns new code, which is then evaluated in its place. This is in contrast to regular functions, which receive values and compute a value at runtime. Macros provide a powerful way to extend the language's capabilities by allowing you to write programs that generate other programs based on arbitrary forms.

The macro system in Elisp is built upon quasiquotation, a technique that combines the use of backquote `` to build a code template, comma , to insert computed pieces, and comma-at ,@ to splice in a list. This powerful toolkit enables the creation of intricate and expressive macros.

One of the most famous examples of a macro in Emacs is `use-package`, which simplifies the configuration process by compiling declarations into the necessary require calls, keymap bindings, hooks, and autoload deferrals. Another notable macro is `define-minor-mode`, which expands into code that creates minor modes in Elisp. These macros demonstrate the power of macros in extending the language's capabilities and making it more expressive.

In conclusion, the beauty of macros in Elisp lies in their ability to blur the line between program and data, leveraging the language's homoiconic nature. By treating code as data, Elisp enables the creation of powerful abstractions and metaprogramming constructs that extend the language's capabilities beyond its original design. The dualism between program and data, as exemplified by Escher's artwork, is a testament to the elegance and flexibility of Elisp as a programming language.