✓ Macro Programming



  • The s-expressions are strings that represent lists.

  • Some examples:

    • ()

    • (1 2 3)

    • (1 (2 3))

  • The parenthesis marks the boundaries of the lists, and the elements of a list is either

    1. an atom

    2. or another list

The s-expression language

Here is the grammar of the s-expression.

s-expr  : (element)*
element : atom
        | s-expr

Atoms can be any of the scalar values:

  • Numbers

  • Strings and characters

  • Symbols

Extension of s-expression in Clojure

Clojure extends the basic s-expression by a few more constructs:

  • Set: #{ ... }

  • Vector: [ ... ]

  • Map: { ... }

Universal Expressiveness of s-expressions

Representation with s-expressions

S-expressions can be used to expresss just about anything. So, in a way, s-expression is a core language that can be used to represent any other language.


def factorial(n):
  if n <= 1:
    return n
    return n * factorial(n-1)

print factorial(100)

  (def factorial (n)
    (if (n <= 1)
      (return n)
      (return (n * (call factorial (n - 1))))))

  (call factorial 100))

Markup language

<Person id="1234">
  <name>Albert Einstein</name>
  (:id "1234")
  (:name "Albert Einstein")
  (:profession "Physicist"))

Stylesheet in CSS

body: {
  font-family: Helvetica;
  margin: 10px 0;
  background: transparent;
;; This encoding requires that
;; the second element of (body ...) list
;; be a list containing even number of atoms.

(body (font-family "Helvetica"
       margin      (10 0)
       background  :transparent))

Clojure programming

Clojure source code is already in s-expression form.

Macro Programming

The reader

A reader is a program that transforms the native syntax to a s-expression.

\[ \mathrm{reader}: \mathrm{Syntax} \to \mathrm{SExpr} \]

Keep in mind that the \(\mathrm{SExpr}\) is to be interpreted by a Lisp runtime environment as a Turing-complete programming environment (such as Clojure).

Magic of Clojure

  • Clojure is homoiconic, so the source code is already in s-expression.

  • Using Clojure s-expression, we can express arbitrary data transformation.

  • What if clojure s-expression is the input to itself?

Macro expansion

\[ \mathrm{Syntax} \overset{reader}{\longrightarrow} \underbrace{\mathrm{SExpr}}_{\mathrm{before}} \overset{macro}{\longrightarrow} \underbrace{\mathrm{SExpr}}_{\mathrm{after}} \]

Macros in Clojure

Macros are functions

(defmacro <function-name>
    [ <arguments>... ]
  • The arguments are s-expression before.

  • The return value must be a valid s-expression after.


(defmacro evaluate [x op y]
    (list op x y))
(evaluate 1 + 2)

Walking through

(evaluate 1 + 2)

is evaluated as during the macro expansion stage.

The body is evaluated with the scope:

x => 1
op => '+
y => 2

So, the body evaluates to

(+ 1 2)


(defmacro evaluate2 [expr]
    (list 'do
          (list 'println (str expr))
          (list 'println "=>" expr)))
(evaluate2 (+ 1 2 3))
(+ 1 2 3)
=> 6

Walk through

(evaluate2 (+ 1 2 3)

creates the following binding during the macro-expansion.

expr => '(+ 1 2 3)


(str expr) => "(+ 1 2 3)"

The returned value is:

(do (println "(+ 1 2 3)")
    (println "=>" (+ 1 2 3)))


In the macro of

(defmacro evaluate2 [expr]
    (list 'do
          (list 'println (str expr))
          (list 'println "=>" expr)))

We need general computation:

  • (str expr) to compute the string representation of expr.

We also need code generation:

  • 'do

  • (list ...)

Language features for macro programming

Generating code is painful

(defmacro inc-10 []
    (list 'let (vector 'x 10) (list clojure.core/inc 'x)))
(macroexpand-1 '(inc-10))
(let [x 10] (#function[clojure.core/inc] x))

Code template

Code template is a piece of valid clojure code that is not evaluated by the evaluator.

We can suppress evaluation using the backtick symbol.

  1. All s-expressions in the template are pure data (with exception).

  2. All symbols are resolved into their fully qualified form.

`(let [x 10] (inc x))
(clojure.core/let [user/x 10] (clojure.core/inc user/x))

This allows easy implementation of macros, but more on this later.

Single substitution in code template

We can exit from a template and evaluate part of the code inside the template.

`(let [x 10
       y ~(rand-int 1000)]
     (println ~(rand-int 1000) x y))
(clojure.core/let [user/x 10 user/y 827] (clojure.core/println 691 user/x user/y))

Slice substitution in code template

We can compute a list and insert it into a code template.

`(let [x 10
       y ~(rand-int 1000)]
     (println ~@(take 3 (repeatedly #(rand-int 1000))) x y))
(clojure.core/let [user/x 10 user/y 414] (clojure.core/println 75 709 326 user/x user/y))

Symbol generation

Code templates generates invalid variable names in the let-form. To fix this, Clojure has a special syntax that denotes new symbols to be inserted into the generated code.

`(let [x# 10
       y# ~(rand-int 1000)]
     (println ~@(take 3 (repeatedly #(rand-int 1000))) x# y#))
(clojure.core/let [x__5428__auto__ 10 y__5429__auto__ 367] (clojure.core/println 590 319 374 x__5428__auto__ y__5429__auto__))

Examples of macros


(defmacro echo [expr]
    (let [message (str expr "=>")]
        `(println ~message ~expr)))
(echo (+ 1 2))
(+ 1 2)=> 3


(defmacro timeit [expr]
    `(let [start# (System/currentTimeMillis)
           result# ~expr
           duration# (- (System/currentTimeMillis) start#)]
         (println ~(str expr)
         (println "Took" duration# "ms")))
(timeit (apply + (range 1E7)))
(apply + (range 1.0E7)) => 49999995000000
Took 225 ms

Infix operator

(defmacro infix [expr]
    (let [[a op b] expr]
        `(~op ~a ~b)))
(infix (1 + 2))