--- title: "A quick peek at lisp macros" url: "https://www.bekk.christmas/post/2022/20/a-quick-peek-at-lisp-macros" canonical_url: "https://simendsjo.me/blog/20220815200323-a_quick_peek_at_lisp_macros" authors: ["Simen Endsjø"] published: "2022-12-20" updated: "2024-11-07T13:05:28Z" language: "en-US" type: "article" tags: ["Utvikling", "lisp", "macro"] --- # A quick peek at lisp macros Macros enable developers to extend a language to accomodate future or domain specific needs without waiting for language updates. In this post, we extend the control flow of the language. ## In short Lisp macros let you treat code as data and build new control-flow constructs on top of the language. The article walks through basic syntax tools like quote and quasiquote, then shows how macros can express patterns such as when, unless, if-let, anaphoric bindings, and looping forms more clearly and with less repetition. - **For:** Developers curious about Lisp macros and metaprogramming - **Good to know beforehand:** Basic programming knowledge and familiarity with Lisp syntax _AI-generated_ ## Introduction Much of Lisps longevity is due to its metaprogramming, that is code that treats code as data. Lisp uses the same syntax for both code and data, which makes manipulating code as easy as manipulating data. Macro functions (or just macros) are just like regular functions, except that the arguments aren’t evaluated before calling, and they should return code (which means data as s-expressions which will be interpreted as code) rather than a value. The macro decides if, when, how and how often an argument is evaluated. This allows macros to remove repetition, extend the semantics of the programming language, or even create new programming languages within the programming language. Most other languages simply do not have the expressive power to do anything like this, or make it different from built-in constructs or difficult to write. I’ll demo a couple of simple macros to extend control flow and looping constructs, and I’ll use C# as a contrast to the lisp code. The intention of this post is meant only to pique your interest in lisp. Production quality implementations of concepts presented here is probably available in libraries for pretty much every lisp out there. ## Basic building blocks Before showing the macros, I’ll explain a few of the building blocks we’ll use. In lisp, as in many other languages, everything is an expression. If you want to execute some effects, you have to wrap them in an expression which somehow returns a value. The most common construct is `progn` which accepts many expressions as arguments and returns the result of the last expression. Several other languages do this by default, and lisp also has many forms which does this implicitly. ```csharp { Effect1(); Effect2(); } ``` ```lisp (progn (effect1) (effect2)) ``` In C#, you can create a new lexical scope using braces. Variables defined within the scope don’t escape the scope. Many programmers don’t use new scopes outside some statements like functions, if, while etc, but they are still available if you want to control visibility of variables, disposing, finalizing etc. ```csharp // stuff before { // stuff before available // new local scope } // stuff before available // things from local scope is unavailable ``` A new scope can be created using `let` in lisp. While `progn` allows several expressions and returns the last, `let` also allows creating new variables in this scope. `let` has an implicit `progn` so you can pass several expressions instead of explicitly stating a `progn`. ```csharp { int x = 1; Effect1(x); Effect2(x); } // x not visible here ``` ```lisp (let ((x 1)) (effect1 x) (effect2 x)) ;; x not visible here ``` The fact that everything is an expression means we don’t have to declare variables ahead of initialization with dummy values. ```csharp var result = null; { // result visible but not initialized while executing statements here Effect1(); // <- we could use result here by mistake // then initialize and result result = SomeResult(); } // We can use result here ``` In lisp, as in other languages with expressions rather than statements, we can write the following. ```lisp (let ((result (progn ;; Cannot accidentally use result in these expressions (effect1) ; <- result undefined ;; Then initialize and return (some-result)))) ;; We can use result here ) ``` ## Code as data and code that writes code That’s about the basics we need before looking into how macros work. Syntax in programming language is parsed into an abstract syntax tree (AST) in order to be further analyzed and manipulated. In lisp we write our programs directly in an AST. So how can we represent the following code as data? ```lisp (let ((x 1)) (+ x 1)) ``` `list` creates a list, `quote` returns the exact symbol/value without evaluating it. ```lisp (list (quote let) (list (list (quote x) 1)) (list (quote +) (quote x) 1)) ``` Fortunately, we don’t have to write code as above. By quoting the first list, everything within is quoted. We can thus rewrite the above with just a single quote at the start, getting the exact same code, but this time as data! ```lisp '(let ((x 1)) (+ x 1)) ``` When creating code that manipulates code, it’s often useful to evaluate certain expressions. When we use the verbose syntax, this is easy. `(list (quote +) x 1)` will evaluate `x` as it’s not quoted, but not `+`. Let’s say we have the following code, and we want to return the code `(+ 1 2)`. Our first attempt returns `(+ x 2)`, which isn’t what we want. ```lisp (let ((x 1)) '(+ x 2)) ``` We have a form similar to `quote` called `quasiquote` or `` ` ``. When using this form, we can `unquote` the expression using `,`, which will evaluate the expression. ```lisp (let ((x 1)) `(+ ,x 2)) ;; same as (list (quote +) x 2) ``` There is also `unquote-splicing`, `,@`, which will unquote a list and flatten it (remove the “(list” and “)” part), e.g. `` `(1 ,@(list 2 3) 4) `` equals `'(1 2 3 4)`. With the basics out of the way, let’s start extending the language with some new control flows. ## New control flow abstractions A regular C# if statement looks pretty much the same as a lisp if expression. ```csharp if (someTest) { Then1(); Then2(); } else { Else1(); Else2(); } ``` ```lisp (if some-test (progn (then1) (then2)) (progn (else1) (else2))) ``` But often, we only care about the “then” or “else” clause. ```csharp if (someTest) { Then1(); Then2(); } ``` The “else” clause is often written by negating test rather than using an empty “then” block ```csharp if (!someTest) { Else1(); Else2(); } ``` Let’s create two new control flow constructs, `when` for the “then” clause and `unless` for the “else” clause. This removes some repetition as well as making the intent clearer. Rather than ```lisp (if some-test (progn (true1) (true2))) ``` We’ll write ```lisp (when some-test (true1) (true2)) ``` It makes it very clear that there is no “else” clause, and we can use an implicit block. Notice that the definition looks pretty much exactly as we would have written the if expression simply because code and data has the same syntax. ```lisp (defmacro when (test &body body) `(if ,test (progn ,@body) nil)) ``` We’ll do the same for the “else” case. ```csharp if (!someTest) { False1(); False2(); } ``` ```lisp (unless some-test (false1) (false2)) ``` ```lisp (defmacro unless (test &body body) `(if ,test nil (progn ,@body))) ``` We could have defined `unless` in terms of `when` and negating `test`, but let’s use `if` directly to avoid the extra function call. As a side-note, truthy and falsy is quite different in some Lisps like Common Lisp (CL) which this article is using. In CL, only `nil` is falsy and every other value is truthy. This means functions can return actual data instead of `true` / `false`, and we don’t have to inspect the value or revert to using only booleans. The pattern below is quite common, but in Lisp we don’t need to store the temporary or checking against a particular value. ```csharp var something = GetSomething(); if (something != null) { True1(); True2(); } ``` ```lisp (when (get-something) (true1) (true2)) ``` But what if the block needs the value too? In that case we need to store the value in a variable in order to use it later. ```csharp var something = GetSomething(); if (something != null) { True1(something); True2(something); } ``` We can write this using a `let` ```lisp (let ((something (get-something))) (when something (true1 something) (true2 something))) ``` `or` is using this fact to return a value rather than evaluating to a boolean. The following is quite common code, and is easily expressed just using `or`. ```csharp var something = GetSomething(); if (something == null) { something = CreateSomething(); } Effect(something); ``` ```lisp (let ((something (or (get-something) (create-something)))) (effect something)) ``` ## Binding the test only for the success case The pattern of binding something and then using it within an expression is a common pattern. In other languages we annoyingly often create temporary values which outlive the expression they are used in. But using macros, we can do this The Right Way; we’ll create `if-let`, `when-let` and `unless-let`. Using these, our code just becomes ```lisp (when-let (something (get-something)) (true1 something) (true2 something)) ;; something unavailable here ``` The macros are no more difficult than what we’ve already seen. ```lisp (defmacro if-let ((id value) then &optional else) `(let ((,id ,value)) (if ,id ,then ,else))) (defmacro when-let (expr &body body) `(if-let ,expr (progn ,@body) nil)) (defmacro unless-let (expr &body body) `(if-let ,expr nil (progn ,@body))) ``` ## Anaphoric macros But we’re not finished yet. We don’t really care about the name `something` in the expression. We could call it `it` and make it available in the scope. This is called “anaphoric” macros. Our previous example thus becomes ```lisp (awhen (get-something) (true1 it) (true2 it)) ``` ```lisp (awhen (or (get-something) (create-something)) (effect it)) ``` ```lisp (defmacro aif (test then &optional else) `(if-let (it ,test) ,then ,else)) (defmacro awhen (test &body body) `(when-let (it ,test) ,@body)) (defmacro aunless (test &body body) `(unless-let (it ,test) ,@body)) ``` Let’s see how a lisp expression using `awhen` and `or` would look like in C#. ```lisp (awhen (or (get-something) (try-other-thing) (make-thing)) (do-thing it)) ``` ```csharp var it = GetSomething(); if (it == null) it = TryOtherThing(); if (it == null) it = MakeThing(); if (it != null) DoThing(it); ``` ## Creating new loops Let’s turn our head over to loops which also has some common patterns; looping until some condition is met. The loop in C# will look different based on what kind of thing we expect. Here is a simple boolean to become `true`, and other types of checks would look different. ```csharp var x = false; while(!x) { // Until x is true } ``` ```lisp (until x ;; Until x is non-nil ) ``` But any complex expression is possible ```lisp (until (> x 10) ;; Until x is greater than 10 ) ``` Looping forever is normal in background processes. It’s easy to express in most languages, but being more explicit could improve readability. ```csharp while (true) { // Forever do this } ``` ```lisp (forever ;; Forever do this ) ``` ```lisp (defmacro until (test &body body) `(do () (,test t) ,@body)) (defmacro while (test &body body) `(until (not ,test) ,@body)) (defmacro forever (&body body) `(while t ,@body)) ``` ## Conclusion The examples are quite contrived and don’t show the real power of macros. But hopefully they show that macros are within reach and allow you to extend your language to fit your domain. Building a program bottom-up by creating a language that allows you to express a solution to your problem clearly, is one of the great features of lisp.