43. Classes and instances in Drip

A method that doesn’t forget

Here is a Drip class. It looks a lot like chapter 7’s JavaScript:

class Cake {
  init(flavour) {
    this.flavour = flavour;
  }
  taste() {
    print "Mmm, " + this.flavour;
  }
}

let c = Cake("lemon");
c.taste();  // Mmm, lemon
let f = c.taste;
f();        // Mmm, lemon

Two differences. There is no new: you call the class like a function, and init plays the constructor. And look at the last line. In JavaScript, const f = p.move; f(); lost its this, because this is decided by the dot in each call^[3]. In Drip, f() still knows it belongs to c. By the end of this chapter you’ll know exactly which object makes that work.

Classes, instances and fields

A class statement makes a DripClass: a name and a Map from method name to DripFunction. Calling the class makes a DripInstance, binds init to it, runs init and returns the instance:

call(interp, args: Value[]): Value {
  const inst = new DripInstance(this);
  this.findMethod('init')
    ?.bind(inst).call(interp, args);
  return inst;
}

(The class’s arity is init’s arity, or 0 if there is no init.) An instance is just its class plus a second Map:

class DripInstance {
  fields = new Map<string, Value>();
  constructor(readonly klass: DripClass) {}
  get(name: Token): Value {
    const n = name.lexeme;
    if (this.fields.has(n))
      return this.fields.get(n)!;
    const m = this.klass.findMethod(n);
    if (m) return m.bind(this);
    throw new RuntimeError(name,
      `Undefined property '${n}'.`);
  }
  set(name: Token, value: Value) {
    this.fields.set(name.lexeme, value);
  }
}

Fields are never declared. b.size = 3 simply creates size if it isn’t there yet. Reading checks the fields first, so a field can hide a method of the same name. In the interpreter, a get expression like c.taste first checks that the object is an instance at all; if not, you get Only instances have properties.

class Box {}

let b = Box();
b.size = 3;
print b.size;
b.size = b.size + 1;
print b.size;
print b;
print b.colour;

this, and bound methods

How does taste’s body find this? Not by a special rule. this is looked up like any other variable, in an environment, at a distance the resolver worked out. The resolver wraps every class’s methods in one extra scope that declares this:

case 'class':
  declare(s.name);
  define(s.name);
  begin();
  scopes.at(-1)!.set('this', true);
  for (const m of s.methods)
    fn(m, m.name.lexeme === 'init'
      ? 'initializer' : 'method');
  end();

So at run time there must be a matching environment with this in it, between a method’s body and the environment where the class was declared. It is made by bind, every time a method is read off an instance:

bind(inst: DripInstance) {
  const env = new Environment(
    this.closure,
  );
  env.define('this', inst);
  return new DripFunction(
    this.decl, env, this.isInitializer,
  );
}

class Cake {
  init(f) { this.flavour = f; }
  taste() {
    print this.flavour;
  }
}
let c = Cake("lemon");
c.taste();

Now the puzzle from the start is solved. let f = c.taste stored the bound method, and its closure holds this = c. Calling f() later, with no dot, makes no difference. The same is true when you pass a method as a callback:

class Tally {
  init() { this.n = 0; }
  add() { this.n = this.n + 1; }
}

fn twice(f) {
  f();
  f();
}

let t = Tally();
twice(t.add);
print t.n;
print t.add == t.add;

Notice the last line: each read of t.add binds again, so it makes a new function value, and two of them aren’t the same object.

init always returns this

init is marked as an initializer (that isInitializer flag), and an initializer’s call always returns the this from its closure, whatever its body does. So calling c.init("plum") directly re-runs it and gives you c back. For the same reason, return "x"; inside init is a resolver error: Can't return a value from an initializer. A bare return; is fine.

Your turn

class Tally {
  init() {}
  add() {}
  value() {}
}

fn twice(f) {
  f();
  f();
}
let t = Tally();
twice(t.add);
print t.value();
t.add();
print t.value();
print Tally().value();

function getProp(inst, name) {
  // your code here
}

What you learned

• A Drip class is a name plus a map of methods. Calling it makes an instance, binds init to it and runs it.
• An instance holds its class and a map of fields. Fields appear when you assign them, and a read checks fields before methods.
• this is an ordinary variable, found at a distance the resolver computed. bind creates the environment that holds it.
• A bound method carries its instance with it, so a Drip method never loses its this, even as a callback.
• An initializer always returns this; returning a value from it is a resolver error.

Next: classes that build on other classes, super, and a hard look at how fast all of this really is.