Re: Is there an easy way to mimic generics with an accept method of a visitor pattern?

[vitamin via Digitalmars-d-learn]

On Thursday, 18 February 2021 at 13:53:19 UTC, Paul Backus wrote:

On Thursday, 18 February 2021 at 11:14:05 UTC, Mina wrote:

I'm following along with the crafting interpreters book (https://craftinginterpreters.com) and it goes into implementing a visitor pattern that returns generic types, so implementing it in D came down to the accept method causing undefined symbol error that goes away when changing it to returning a concrete type, so here's what I've got working (https://github.com/MKamelll/dlox/blob/main/source/loxast.d) and here's the book's implementation (https://github.com/munificent/craftinginterpreters/blob/master/java/com/craftinginterpreters/lox/Expr.java).

Thanks.

In D, because generics are implemented using templates ("monomorphization"), generic methods can't be virtual and can't be overridden in child classes. As you've discovered, that means `accept` has to work entirely with concrete types rather than generic ones.

One way to solve this (which is used in the D compiler's source code) is to have both `accept` and `visit` return `void` and put the result inside the visitor object as a member variable. For example:

interface Visitor
{
    void visit(Expr.Literal expr);
    // etc.
}

class AstPrinter : Visitor
{
    string result;

    override void visit(Expr.Literal expr)
    {
        if (!expr.literal.hasValue) result =  "nil";
        else result = lexLiteralStr(expr.literal);
    }

    // etc.

    string print(Expr expr)
    {
        expr.accept(this);
        return result;
    }
}

Another possibility is to use discriminated unions and tag-based dispatch (i.e., switch statements) instead of classes and virtual method dispatch. This would make it a bit harder to follow the book, but might be a better learning experience if you're up for a challenge.

Or combination of discriminate uninons and classes:

/+dub.sdl:
dependency "sumtype" version="~>0.10.0"
+/
import std.stdio;

import sumtype;

alias Expression = SumType!(
    ExprValue,
    ExprBinary,
    ExprUnary
);

class Expr{
    abstract Expression expression()pure nothrow @safe @nogc;

}

class ExprValue : Expr{
        string val;

    override Expression expression()pure nothrow @safe @nogc{
        return Expression(this);
    }

    this(string val)pure{
        this.val = val;
    }

}

class ExprBinary : Expr{
    string op;
    Expr left;
    Expr right;

    override Expression expression()pure nothrow @safe @nogc{
        return Expression(this);
    }

    this(string op, Expr left, Expr right)pure{
        this.op = op;
        this.left = left;
        this.right = right;
    }

}

class ExprUnary : Expr{
    string op;
    Expr expr;

    override Expression expression()pure nothrow @safe @nogc{
        return Expression(this);
    }

    this(string op, Expr expr)pure{
        this.op = op;
        this.expr = expr;
    }
}

string printExpr(Expr expr){
    assert(expr !is null);

    static auto impl(E)(E e){
        static if(is(E == ExprValue)){
                return e.val;
        }
        else static if(is(E == ExprUnary)){
                return e.op ~ printExpr(e.expr);
        }
        else static if(is(E == ExprBinary)){
                return printExpr(e.left) ~ e.op ~ printExpr(e.right);
        }
        else static assert(0, "no impl");

    }

    return expr.expression.match!impl;
}
void main(){
    // (1 + (- 2 ))
    Expr expr = new ExprBinary(
        "+",
        new ExprValue("1"),
        new ExprUnary(
            "-",
            new ExprValue("2")
        )
    );

    writeln(expr.printExpr());


}