Macro programming¶

Macros are functions that take code as input and generates code as output.
Recall that code is data in Clojure. All Clojure code is expressed as a mixture of nested lists and vectors.

;
; This is a macro that generates the code to print "Hello"
;
(defmacro hello []
    (list 'print "Hello"))

#'user/hello

(hello)

Hello

nil

;
; Clojure provides a facility (macroexpand) that allows us
; to see what code is generated from a macro call.
;
(macroexpand '(hello))

(print "Hello")

;
; This shows how limiting a function is.  It cannot
; examine _code_ as data.
;
(defn hello [expr]
    (println "Hello: " expr))

#'user/hello

;
; Note, the input to `hello` is the result of the code, not the code itself.
;
(hello (+ 1 2 3))

Hello:  6

nil

;
; But macro gets the code as data *before* it is evaluated.
;
(defmacro hello [expr]
    (let [expr-as-str (str expr)]
        (list println "Hello" expr-as-str)))

#'user/hello

(macroexpand '(hello (+ 1 2 3)))

(#function[clojure.core/println] "Hello" "(+ 1 2 3)")

(hello (+ 1 2 3))

Hello (+ 1 2 3)

nil

Clojure's programming constructs that help us to generate code¶

Suppose we want to generate

(let [x 10] (inc x))

;
; From first principle, very very impractical
;
(list 'let (vector 'x 10) (list clojure.core/inc 'x))

(let [x 10] (#function[clojure.core/inc] x))

;
; Clojure offers the *backtick* escape form.
; *NOTE*:
; backtick: `
; singlequote: '
; We want to use the backtick form.
;

`(let [x 10] (inc x))

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

;
; The backtick allows us to disable the escape mode.
;
(defn get-limit[] (rand-int 100))

#'user/get-limit

; Want to generate this
; (let [x __] (inc x))
;
`(let [x ~(get-limit)]
     (inc x))

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

Note: The tilda ~(...) form is executed during macro expansion phase, and the result is inserted into the quoted form.

There is another macro expansion phase form, called slicing. Suppose we want to generate the following code:

(println ____ _____ _____)

(defn get-limits []
    (take 3 (repeatedly get-limit)))

#'user/get-limits

(get-limits)

(38 5 27)

;
; Here the insertion by ~ is not sufficient.  We don't want to insert back a list,
; but we want to insert the result as a sublist of the (println   .... ) form.
;
`(println ~(get-limits))

(clojure.core/println (40 96 57))

The ~@expr will execute expr in macro expansion phase, and insert the result as a list back into the form one element at a time.

`(println ~@(get-limits))

(clojure.core/println 18 26 33)

Note:¶

There is one more code generate feature, symbol generation.

Let's write some interesting macros¶

(defmacro verbose [expr]
    ; Remember expr is a data fragment
    `(do (println ~(str expr))
         (println "=>" ~expr)))

#'user/verbose

(verbose (+ 1 2 3))

(+ 1 2 3)
=> 6

nil

(verbose (repeat 3 (+ 1 2)))

(repeat 3 (+ 1 2))
=> (3 3 3)

nil

; Don't forget the single quote the form you
; want to expand.
(clojure.pprint/pprint
    (macroexpand '(verbose (repeat 3 (+ 1 2)))))

(do
 (clojure.core/println "(repeat 3 (+ 1 2))")
 (clojure.core/println "=>" (repeat 3 (+ 1 2))))

nil

Infix operation form¶

(+ 1 2)

3

(+ 1 2 3 4 5 67 8)

90

(defmacro infix [form]
    (let [[a op b] form]
        `(~op ~a ~b)))

#'user/infix

(infix (1 + 2))

3

(macroexpand '(infix (10 * 20)))

(* 10 20)

Build a timer macro¶

(--- (apply + (range 1e6)))

; => (apply = (range 1e6)) took 100 ms
847298729357

(defn now [] (System/currentTimeMillis))
(now)

1606404947079

(defmacro ---
    [expr]
    `(let [start# (now)
           result# ~expr
           duration# (- (now) start#)]
         (println ~(str expr) "took" duration# "ms")
         result#))

#'user/---

(clojure.pprint/pprint
    (macroexpand-1 '(--- (+ 1 2))))

(clojure.core/let
 [start__5576__auto__
  (user/now)
  result__5577__auto__
  (+ 1 2)
  duration__5578__auto__
  (clojure.core/- (user/now) start__5576__auto__)]
 (clojure.core/println "(+ 1 2)" "took" duration__5578__auto__ "ms")
 result__5577__auto__)

nil

(--- (apply + (range 1e6)))

(apply + (range 1000000.0)) took 54 ms

499999500000