26. Meet Drip

A language you can hold in your head

JavaScript is a big language, with many years of features piled on top of each other. Starting there is a poor way to learn how a language works.

So for Part III you’ll build a smaller one. It’s called Drip. Drip is a dialect of Lox, the language Robert Nystrom designed for his book Crafting Interpreters^[1]. It is Lox with two words respelled: fn instead of fun and let instead of var, so it looks more like the JavaScript you already know. Every Drip test program in this book is adapted from Lox’s MIT-licensed test suite.

Every example in this chapter runs on the interpreter you are about to write. Edit them freely.

Values and variables

Drip has numbers, strings, true and false, and nil, which means “no value”, like JavaScript’s null. Variables are made with let, and print is a statement, not a function, so it needs no parentheses:

let cups = 3;
print cups + 1;  // 4

print 7 / 2;
print "drip" + "drop";
print 3 < 4 and 4 < 5;
print !true;
print nil;

let cups = 3;
cups = cups + 1;
print cups;
print 0.1 + 0.2;

// print "a" + 1;

A few things will feel familiar. Every number is a 64-bit float, just like in JavaScript, so 0.1 + 0.2 has the same rounding you met in Part I. Strings join with +. Comments start with //. Logic uses the words and and or instead of && and ||.

Deciding and repeating

if, while and for look the way you’d expect. One rule is different from JavaScript: only nil and false count as false. Everything else, including 0 and the empty string "", counts as true.

let n = 1;
while (n < 50) {
  n = n * 2;
}
print n;

for (let i = 0; i < 3; i = i + 1) {
  print i;
}

if (0) print "0 is true";
else print "0 is false";

Functions and closures

Functions are declared with fn. They are values, so a function can return another function, and the inner one remembers the variables around it. That is a closure, exactly as in chapter 6:

fn square(x) {
  return x * x;
}
print square(4);

fn makeCounter() {
  let n = 0;
  fn count() {
    n = n + 1;
    return n;
  }
  return count;
}

let c = makeCounter();
print c();
print c();
print makeCounter;

Each call to makeCounter makes a new n, and the count it returns keeps that n alive. Making that work is the job of chapter 41.

Classes

Drip has classes with methods, this and a constructor. The constructor is the method called init. You make an instance by calling the class like a function: there is no new. A class inherits from another with <, and super calls the parent’s version of a method:

class Cup {
  init(ml) {
    this.ml = ml;
  }
  pour(x) {
    this.ml = this.ml - x;
    return this.ml;
  }
}

class Mug < Cup {
  pour(x) {
    print "careful, hot";
    return super.pour(x);
  }
}

let m = Mug(300);
print m.pour(50);
print m;

Dynamic typing

TypeScript, from chapter 13, checks types before your program runs. Drip doesn’t. A Drip variable can hold any kind of value, and it can hold a number now and a string later. Step through what happens when a + meets the wrong kind of value:

let a = 1;
let b = 2;
print a + b;
b = "2";
print a + b;

Dynamic doesn’t mean “anything goes”. JavaScript is dynamically typed too, but its + quietly converts: "a" + 1 is "a1". Drip refuses and says so. Both are legitimate designs. To try it, remove the // in front of the last line of the first example above.

Who decides what a program means?

Here’s a question with no obvious answer: what should print 7 / 2; show? 3? 3.5? An error? Each is a reasonable choice, and different languages make different ones. Drip prints 3.5. Something has to write that decision down, so that every implementation of the language makes the same choice.

JavaScript’s spec is a document called ECMA-262, maintained by a committee called TC39^[2]. Drip has no standards committee. Its spec is the description of Lox in Crafting Interpreters, with the two respellings, made checkable by 265 test programs in companion/corpus. Each one writes down what it should do in comments. Here are four lines from one of them, if/truth.drip:

// Everything else is true.
if (true) print true; // expect: true
if (0) print 0; // expect: 0
if ("") print "empty"; // expect: empty

Other tests expect an error instead, written as // expect runtime error: followed by the exact message. Run a test, and if the output differs from its comments in any way, the implementation has a bug.

Your turn

Your first Drip programs. The tests check the exact output, line by line.

fn sumTo(n) {
  // your code here
}

print sumTo(10);
print sumTo(100);

class Counter {
  // your code here
}

let a = Counter();
print a.inc();
print a.inc();
let b = Counter();
print b.inc();

What you learned

• Drip is a small dialect of Lox, with fn and let. It has numbers, strings, booleans, nil, functions, closures and classes.
• Only nil and false are false in Drip. print is a statement. Classes use init, this, < and super.
• Dynamic typing: values carry their types, and Drip checks them as each operation runs. A wrong type is a runtime error, not a silent conversion.
• A language spec says precisely what programs mean. Drip’s is made concrete by 265 test programs that both of its implementations must pass.

Next: the first stage of the pipeline. What exactly is a “word” of Drip?