Code generator and visitor pattern

[Mick Krippendorf]

Karsten Wutzke wrote:
> The visitor pattern uses single-dispatch, that is, it determines 
> which method to call be the type of object passed in.

Say, in Python, I have an object o and want to call one of it's methods,
say m. Then which of possibly many methods m to call is determined by
the type of o, and nothing else (at least without further magic) -
hence, it is single dispatch. The VP uses two single dispatch calls (one
being a callback) to accomplish double dispatching.

Java has a form of multiple dispatch through function overloading. In
fact, it's still single dispatch, because which of the targets
overloaded methods gets called is determined at compile time by the
staticly known types of the methods parameters, AKA the formal parameter
types.

Anyway. Although VP *uses* double dispatch, it does not necessarily rely
on function overloading. In Java the VP is most often implemented like this:

<java>

interface IASTNode {
    void accept(IASTVisitor);
}

class IfNode implements IASTNode {
    void accept(IASTVisitor visitor) {
        visitor.visit(this);
    }
}

class ElseNode implements IASTNode {
    void accept(IASTVisitor visitor) {
        visitor.visit(this);
    }
}

interface IASTVisitor {
    void visit(IfNode node);
    void visit(ElseNode node);
    ...
}
class PrettyPrinter implements IASTVisitor {
    public void visit(IfNode n) {
        ...
    }
    public void visit(ElseNode n) {
        ...
    }
}

</java>

but it could as well be implemented like this:

<java>

interface IASTNode {
    void accept(IASTVisitor);
}

class IfNode implements IASTNode {
    void accept(IASTVisitor visitor) {
        visitor.visitIfNode(this);
    }
}

class ElseNode implements IASTNode {
    void accept(IASTVisitor visitor) {
        visitor.visitElseNode(this);
    }
}

interface IASTVisitor {
    void visitIfNode(IfNode node);
    void visitElseNode(ElseNode node);
    ...
}
class PrettyPrinter implements IASTVisitor {
    public void visitIfNode(IfNode n) {
        ...
    }
    public void visitElseNode(ElseNode n) {
        ...
    }
}

</java>

If Java were *really* a multiple dispatch language, it wouldn't be
necessary to repeat the accept-code for every subclass. Instead a single
accept method in the base class would suffice. In fact, with true
multiple dispatch VP wouldn't even be needed.


Regards,
Mick.