Wednesday, January 4th 2012, 12:00:00 am

I’m a fan of the visitor pattern for its emulation of dynamic dispatch and its ability to extend functionality of a tree of objects.

UPDATE (20 June 2013)

I messed up some in this post. A kind person in Spain helped me figure that out. You can find the new post and code at

Follow-Up to Python Visitor.

Back to the original article…

In lanugages that do not support method overloading, the visitor pattern tends to fall apart. Python is one of those languages. So, in an effort to have the same effect in Python, here’s some code that does that. I’m just amazed at how few lines it takes to create this effect.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# visit.py

import inspect

__all__ = ['on', 'when']

def on(param_name):
  def f(fn):
    dispatcher = Dispatcher(param_name, fn)
    return dispatcher
  return f


def when(param_type):
  def f(fn):
    frame = inspect.currentframe().f_back
    dispatcher = frame.f_locals[fn.func_name]
    if not isinstance(dispatcher, Dispatcher):
      dispatcher = dispatcher.dispatcher
    dispatcher.add_target(param_type, fn)
    def ff(*args, **kw):
      return dispatcher(*args, **kw)
    ff.dispatcher = dispatcher
    return ff
  return f


class Dispatcher(object):
  def __init__(self, param_name, fn):
    frame = inspect.currentframe().f_back.f_back
    top_level = frame.f_locals == frame.f_globals
    self.param_index = inspect.getargspec(fn).args.index(param_name)
    self.param_name = param_name
    self.targets = {}

  def __call__(self, *args, **kw):
    typ = type(args[self.param_index])
    d = self.targets.get(typ)
    if d is not None:
      return d(*args, **kw)
    else:
      issub = issubclass
      t = self.targets
      ks = t.iterkeys()
      return [t[k](*args, **kw) for k in ks if issub(typ, k)]

  def add_target(self, typ, target):
    self.targets[typ] = target

We can use it in the following way. Imaginge we have an abstract syntax tree with nodes that accept a visitor. The following code would correctly print an infix assignment expression.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import visit

class AbstractSyntaxTreeVisitor(object):
  @visit.on('node')
  def visit(self, node):
    """
    This is the generic method that initializes the
    dynamic dispatcher.
    """

  @visit.when(BaseNode)
  def visit(self, node):
    """
    Will run for nodes that do specifically match the
    provided type.
    """
    print "Unrecognized node:", node

  @visit.when(AssignmentExpression)
  def visit(self, node):
    """ Matches nodes of type AssignmentExpression. """
    node.children[0].accept(self)
    print '='
    node.children[1].accept(self)

  @visit.when(VariableNode)
  def visit(self, node):
    """ Matches nodes that contain variables. """
    print node.name

  @visit.when(Literal)
  def visit(self, node):
    """ Matches nodes that contain literal values. """
    print node.value

Raw code available at visit.py.