Should I use a Visitor when my AST is just an array of arrays?

Question

I've seen the Visitor pattern used to walk an AST. To use this pattern, you add add an accept(visitor) method on the AST node objects. This method calls visitor.visit(self) which, in turn, "processes" the node to get the desired result (ex. a pretty-printed version of the AST).

Note, that you generally have to modify the nodes themselves to add the method. But, what if your AST is using built-in objects. Ruby's Ripper library returns an AST as an array of arrays. I could add the accept method as follows:

class Array
  def accept(visitor)
    visitor.visit(self)
  end
end

Looking at the documentation for Array, there is no accept method currently, so there won't be a conflict. But, this doesn't quite feel right to me, especially if I'm writing a library myself. I wouldn't want to "pollute" a built-in object that others might be relying on.

This isn't unique to Ruby, though, as I could add an extension method in C# to do a similar thing.

My question is: should I be using the Visitor pattern in this scenario, or should I write a recursive function that simply takes in the data-type I'm working on and returns the answer I want?

Answer 1

The Visitor Pattern is a known solution to circumvent a recurrent problem (the problem here might be only applied to programming languages that do not provide multiple dispatch).

As you seem to aknowledge, many times one desires to clearly separate the data structure from what one might want to do with it.

Generally, you have an hierarchy of classes (a tree with different kinds of nodes). Yet, in this case, I don't see that happening. So I wonder why would you want to use the Visitor pattern in the first place. Wouldn't it just be easier to create different classes that take your array as input and process it?