Open Is Good

Case Study: AST

interface Node {
  double value();
};

const etc elided, code formatted to "slide style"

Case Study: AST

class Number : Node
{
  this(double value) {
    this.val = value;
  }

  double value() {
    return val;
  }

  double val;
}

Case Study: AST

class Plus : Node
{
  this(Node left, Node right) {
    this.left = left;
    this.right = right;
  }

  double value() {
    return left.value + right.value;
  }

  Node left, right;
}

Case Study: AST

class Times : Node
{
  this(Node left, Node right) {
    this.left = left;
    this.right = right;
  }

  double value() {
    return left.value * right.value;
  }

  Node left, right;
}

Case Study: AST

void main() {
  Node expr =
    new Times(new Number(2),
      new Plus(new Number(3), new Number(4)));
  writefln("value = %s", expr.value); // value = 14
}

Case Study: AST

void main() {
  Node expr =
    new Times(new Number(2),
      new Plus(new Number(3), new Number(4)));
  writefln("%s = %s", expr.toRPN, expr.value);
  // 2 3 4 + * = 14
}

AST: Add a Member Method?

interface Node {
  // as before
  string toRPN();
};

class Plus : Node {
  // as before
  string toRPN() {
    return left.toRPN ~ " " ~ right.toRPN ~ " +";
  }
}

// same for Number and Times

...if it needs to be virtual, make it a member function ???

banana -> gorilla -> jungle

AST: Type Switch?

string toRPN(Node node) {
  if (auto expr = cast(Number) node) {
    return format("%g", expr.value);
  } else if (auto expr = cast(Plus) node) {
    return toRPN(expr.left) ~ " " ~ toRPN(expr.right) ~ " +";
  } else if (auto expr = cast(Times) node) {
    return toRPN(expr.left) ~ " " ~ toRPN(expr.right) ~ " *";
  }
  assert(0, "unknown node type");
}

needs modification each time a new Node subtype is added

AST: Visitor?

interface Node {
  // same as before
  interface Visitor {
    void visit(Number expr);
    void visit(Plus expr);
    void visit(Times expr);
  }

  void accept(Visitor viz);
};

AST: Visitor?

class Number : Node {
  // same as before
  void accept(Visitor viz) { viz.visit(this); }
}

class Plus : Node {
  // same as before
  void accept(Visitor viz) { viz.visit(this); }
}

class Times : Node {
  // same as before
  void accept(Visitor viz) { viz.visit(this); }
}

AST: Visitor?

class RPNVisitor : Node.Visitor {
  void visit(Number expr) {
    result = format("%g", expr.val);
  }
  void visit(Plus expr) {
    expr.left.visit(this);
    string l = result;
    expr.right.visit(this);
    result = l ~ " " ~ result ~ " +";
  }
  // Times
  string result;
}

ugh, yuck!

AST: Visitor?


string toRPN(Node node) {
  auto viz = new RPNVisitor();
  node.visit(viz);
  return viz.result;
}

my, that was a lot of work

and, what does it even gain us?

AST: Function Table?

alias RPNFormatter = string function(Node);
RPNFormatter[TypeInfo] RPNformatters;

static this() {
  RPNformatters[typeid(Number)] =
  function string(Node node) {
    return format("%g", (cast(Number) node).val);
  };
  RPNformatters[typeid(Plus)] =
  function string(Node node) {
    auto expr = cast(Plus) node;
    return toRPN(expr.left) ~ " "
      ~ toRPN(expr.right) ~ " +";
  };
}

AST: Function Table?

string toRPN(Node node) {
  return RPNformatters[typeid(cast(Object) node)](node);
}

not bad, actually

	Jet	Bus+Train	Cab
Employee	R,X	E,P	R,X
Manager	R,X	E,P	M,C
Founder	F,X	F,X	F,X

	versus	via	delta
virtual function	1-method	object	37%
virtual function	1-method	interface	125%
double dispatch	2-method	objects	28%

Open Is Good