Writing compiler passes in meander

[bsless]

Because, why not?

I don't remember how I got to it but this talk inspired me to try to apply meander to tools.analyzer's output AST. Like Haskell's Core it has a small set of primitives and I thought the approach of graph reduction / term rewriting is a good fit for meander.

The first case I tried to tackle was beta reduction.

Formally: (\x -> B) E -> B[x/E] (replace all occurrences of x with E)
In Clojure we can break the problem in two, similarly to how Haskell's compiler does:

• transform application to let-binding
• propagate constants

((fn [x] body) expr)
(let [x expr] body)

And now in meander:

  (m/rewrite
    node
    {:op :invoke
     :args [!args ..?n]
     :fn {:op :fn
          :methods
          [{:fixed-arity ?n
            :variadic? false
            :params
            [{:op :binding
              :local :arg
              :name !name
              :atom !atom} ...]
            :body ?body}
           ..1]}} ;; there can be only one!
    {:op :let
     :children [:bindings :body]
     :bindings
     [{:op :binding
       :local :let
       :name !name
       :atom !atom
       :init !args
       :children [:init]} ...]
     :body ?body}))

Next step - constant and copy propagation!