What is the easiest way to update an immutable AST?

Question

While working with macros, I have reached the point (I have been trying hard to avoid it) where I need to update those nodes in the AST which hold certain condition. For instance, let's say I would like to update each node:

Literal(Constant(1))

with the value:

Literal(Constant(2))

Those AST nodes could be anywhere in the expression tree, so I cannot use an ad-hoc pattern matcher. Obviously, the last thing I would like to do is to code a full pattern matcher which is able to cover all the compiler primitives. I have been searching in the API but I have the impression that methods such as collect and the traversable family are not good enough to fulfill my needs, since they treat the tree as a linear thing, and I want the whole updated tree as a result. So, is it possible to update an immutable expression tree in a smart way? Why doesn't exist such 'update' operation in the standard API?

For plugins there is a TreeTransformer. I suppose there must be a similar for macros, perhaps even the same. — pedrofurla, Jul 09 '12 at 15:17
Probably you will want to check out [zippers](http://anti-xml.org/zippers.html) — Nikita Volkov, Jul 09 '12 at 15:21
@NikitaVolkov, i'd say that if he wasn't asking in the context of macros. — pedrofurla, Jul 09 '12 at 15:39
What I talked about http://www.scala-lang.org/archives/downloads/distrib/files/nightly/docs/compiler/index.html#scala.tools.nsc.transform.Transform - but it seems to be for plugins only. — pedrofurla, Jul 09 '12 at 15:46
Transformers seem really interesting. I'm going to look for its possible application in macros. Thank you! — neutropolis, Jul 09 '12 at 16:12

score 3 · Accepted Answer · answered Jul 09 '12 at 18:57

3

Here's an example of using an AST transformer in a Scala macro:

https://github.com/retronym/macrocosm/blob/171be7e/src/main/scala/com/github/retronym/macrocosm/Macrocosm.scala#L129

answered Jul 09 '12 at 18:57

retronym

54,768
12
155
168

I really have to look up the source code for Transformer. It looks like the XML transform library, and that library has exponential performance on the depth of the tree. – Daniel C. Sobral Jul 09 '12 at 20:21
A wild shot at the issue: does this relate to top-down vs bottom-up traversal? In a top-down traversal, changing a leaf implies rebuilding the tree above. The implementation of `traceImpl`, in the link above, suggests that new trees are constructed bottom-up (at least there). But, in general, it depends on how you call `super.transform`. – Blaisorblade Jul 27 '12 at 01:33

score 2 · Answer 2 · edited May 23 '17 at 12:15

Modifying poly-typed nodes in data structures generically is a classic case of datatype generics (parameterization of code via type constructor).

Several approaches exist for such operations, such as the "Scrap Your Boilerplate" approach, which define datatype generic traversal functions.

In Haskell, the node update function is parameterized in two dimensions: by datatype and by code -- so you can apply different update functions to different types, anywhere in a structure:

-- | Apply a transformation everywhere in bottom-up manner
everywhere :: (forall a. Data a => a -> a)
           -> (forall a. Data a => a -> a)

Doing so in Haskell relies heavily on type classes. In Scala, there are several ported examples

What is the easiest way to update an immutable AST?

2 Answers2

Linked