An introduction to deep code-walking macros with Clojure (2013) | Hacker News Reader

An introduction to deep code-walking macros with Clojure (2013)

blog.fogus.me

76 pointsfogus6 comments

As an aside, Julia's MacroTools.jl defines pre- and post- code walking in four lines:

    walk(x, inner, outer) = outer(x)
    walk(x::Expr, inner, outer) = outer(Expr(x.head, map(inner, x.args)...))

    postwalk(f, x) = walk(x, x -> postwalk(f, x), f)
    prewalk(f, x)  = walk(f(x), x -> prewalk(f, x), identity)

It's dead simple and obvious in retrospect, but I don't think I would have ever thought of that! I've always wondered if there's a lineage to this set of definitions. Does anyone know?

I love this sort of thing, but I often get the sense from Clojurists I’ve worked with that macros are seen as too complicated (even slightly naughty) for most codebases. Always seems a shame as it’s the main superpower you’re getting from Lisp.

I programmed in Clojure for many years and now a couple in Elixir (which, though not a Lisp does have excellent macro support).

I think I wrote three macros in my time with Clojure and none with Elixir. That’s because mostly I don’t need to, I can solve it with functions.

However my work in both languages rests on a lot of macros included in the stdlib and other libraries. Those macros make my life much easier and, when you really need macro power yourself it is right there.

Writing good macros can be challenging and supporting them after even more so. So it’s a power I use sparingly. But I depend upon macros all the time.

This is my experience also (10+ years with Clojure).

Macros extend the language. I don't need to do that often. I think I've written a dozen macros in ten years and deleted all but one of them.

My current codebase has two macros, one I wrote and that only supports some repetitive behaviour in a test namespace.

Clojure's super-power is solving problems on the JVM and in the browser with one language consisting of well thought out datastructures and a suberb core library of functions that operate on those datastructures.

That, and great host interop. And Instaparse, which is a delight!

Macros extend the language so you're writing in a language adapted for your domain. That can be fun and productive!

I agree Instaparse is delightful, although pretty slow compared to clj-antlr, which just speaks to your point about host interop. :)

Depending on macros became a code smell for me as I got better at Clojure.

Reply on news.ycombinator.com