Clojure Macros

Macros, defined Metaprogramming is writing code that produces code Metaprogramming is particularly easy in the Lisp family of languages, because of homoiconicity “All code is data, and all data is code” In Lisp languages, macros are the primary means of doing metaprogramming A macro definition is like a function definition, with three important differences Arguments to a macro are not evaluated Macro calls are evaluated at compile time The return value of a macro should be executable code

A trivial macro: triple-do (defmacro triple-do [form] (list 'do form form form) ) The do is quoted, so it is put as is into the result list Three copies of the value passed in to the form are put into the list (triple-do (println "Hello")) Result: The list (do (println "Hello") (println "Hello") (println "Hello")) If executed from the REPL, the result is Hello Hello Hello nil

Quotes and unquotes The usual way of quoting something is to put a single quote mark in front of it: '(a b c) The backquote does the exact same thing: `(a b c) However, things within a backquote can be “unquoted” and evaluated, by putting a tilde, ~, in front of them Quotes and unquotes can be nested, to any level The following are equivalent: (defmacro triple-do [form] (list 'do form form form) ) (defmacro triple-do [form] `(do ~form ~form ~form) ) The second of these is called a “template” For complex macros, templates can be a lot easier to read, because they “look like” the code that is generated

Splicing unquotes println can take multiple arguments, which it prints in order Suppose you wanted to write a macro that prints its arguments in reverse order You might try (defmacro rev-println [args] `(println ~(reverse args)) ) Given a list of values, this will print them as a list (rev-println `(a b c)) would print (c b a), not c b a The splicing-unquote operator, ~@, will insert the list values individually, not as a list (defmacro rev-println [args] `(println ~@(reverse args)) )

Generating symbols Just as in a function, you can use let to define the names of local variables These names can be used in the generated code, where they will appear as written However, the names in the generated code may conflict with other names in use where the macro is called To avoid this issue: in any syntax-quoted form (forms using the back tick), add the # symbol to the end of any local names Clojure will replace these names with unique, generated names Example: A println macro that also returns the value printed (defmacro debug-println [expr] `(let [result# ~expr] (println (str “Value is: “ result#)) result# ) )

Debugging To see what you get as the result of expanding a macro, use macroexpand Example: (macroexpand '(triple-do (println "Hello"))) gives (do (println "Hello") (println "Hello") (println "Hello"))

When to use macros General rule: If you can do it with a function, do it with a function Macros are easy to describe but difficult to reason about The primary thing that macros do for you is allow you to modify the language by creating new control structures and formalizing recurring patterns

The End