Question

I got interested in this discussion about AST construction and evaluation in various languages. I am working on a solution in Java just to see what I can learn from this problem.

The code I have below compiles, but produces an incorrect result (namely an “oops” exception). It doesn’t work because Java lacks runtime dispatch. Is there any simple workaround for that? How about complicated workarounds? E.g. using generics to give hints to the compiler? I’m just guessing here.

Some ideas that I’ve ruled out: (1) Use instanceof to dispatch by argument type at run time. (2) Build a look-up table which maps argument types to appropriate handlers. (3) Put an evaluation function in each subclass of E which evaluates that subclass appropriately.

I’ve ruled out (1) and (2) because I want to get the compiler and/or runtime to do that work for me. I’ve ruled out (3) because I want to separate the evaluation code from the expression representation; the idea being that there might be multiple operations (reordering, simplification) on the representation.

Here’s what I have so far. As noted above, this code produces an incorrect result.

import java.util.*;

public class EV
{
    public static Integer ev (E e, Map <String, Integer> env) { throw new RuntimeException ("oops: " + e); }
    public static Integer ev (V e, Map <String, Integer> env) { return env.get (e.name); }
    public static Integer ev (C e, Map <String, Integer> env) { return e.value; }
    public static Integer ev (P e, Map <String, Integer> env) { return ev (e.a1, env) + ev (e.a2, env); }
    public static Integer ev (T e, Map <String, Integer> env) { return ev (e.a1, env) * ev (e.a2, env); }

    public static void main (String [] a)
    {
        E e = new P (new T (new C (2), new V ("a")), new V ("b"));
        Map <String, Integer> env = new Hashtable <String, Integer> ();
        env.put ("a", 123);
        env.put ("b", 456);
        System.out.println ("ev (e, env) => " + ev (e, env));
    }
}

class E {}

class V extends E
{
    String name;
    public V (String name) { this.name = name; }
}

class C extends E
{
    Integer value;
    public C (Integer value) { this.value = value; }
}

class P extends E
{
    E a1, a2;
    public P (E a1, E a2) { this.a1 = a1; this.a2 = a2; }
}

class T extends E
{
    E a1, a2;
    public T (E a1, E a2) { this.a1 = a1; this.a2 = a2; }
}

Answer 1

For doing this in a single-dispatch OO language like Java, this is a classic use-case for the Visitor Pattern, especially if you are also interested in the pretty-print operations mentioned in your comment. It might apply to some of the other operations mentioned in your comment, though they’re a less natural fit.