Create Custom Control Flow with Clojure Macros

Custom control flow is the classic macro use case. The macro receives a body as unevaluated forms, decides where that body goes, and returns ordinary Clojure code.

That does not mean every missing Java keyword deserves a macro. Clojure already has if, when, cond, case, loop, recur, doseq, sequence operations, and higher-order functions. A custom control macro should make evaluation clearer, not recreate Java syntax out of habit.

A Useful Wrapper: Timing a Body

This macro keeps the caller’s body as normal Clojure code while wrapping it in timing behavior:

1(defmacro with-timing [label & body]
2  `(let [started# (System/nanoTime)]
3     (try
4       ~@body
5       (finally
6         (println ~label "took"
7                  (/ (- (System/nanoTime) started#) 1000000.0)
8                  "ms")))))

Usage stays readable:

1(with-timing "load users"
2  (load-users db)
3  (refresh-cache!))

A function can receive a thunk, but the call site becomes less natural:

1(with-timing-fn "load users"
2  (fn []
3    (load-users db)
4    (refresh-cache!)))

The macro is justified only if preserving the direct body shape matters enough to accept macro complexity.

Function or Macro?

Review the Expansion

1(macroexpand-1
2  '(with-timing "load users"
3     (load-users db)))

When reviewing the expansion, check that the body appears exactly where intended, temporary locals are generated, and no caller expression is duplicated.

Avoid Java Syntax Nostalgia

Java developers often reach for a macro to recreate a familiar loop:

1(repeat-until done?
2  (step!))

That can be valid, but it is often less clear than an ordinary Clojure loop or sequence pipeline. Before adding a control macro, ask whether a reader would understand the expansion faster than they would understand the macro name.

Control-Flow Macro Checklist

Knowledge Check