38. Control flow

A program that can’t change its mind

Every Drip program so far runs straight down the page. Each statement runs exactly once, in order, and then the program ends. You can’t print the numbers 1 to 100 without writing 100 print statements, and you can’t do something only sometimes.

This chapter adds the three statements that fix that: if, while and for. Plus two operators, and and or, which turn out to be control flow in disguise.

Choosing: if

The parser already turns if (c) A else B into a node with three children: condition, then and an optional else. Running it takes three lines of the companion’s interpreter.ts:

case 'if': {
  const c = this.evaluate(s.condition);
  if (isTruthy(c)) this.execute(s.then);
  else if (s.else) this.execute(s.else);
  return;
}

Evaluate the condition, ask whether it’s truthy with chapter 35’s isTruthy (only nil and false are falsey), and execute one of the branches. The other branch’s tree is never visited, so a runtime error hiding in it can’t happen.

Notice the trick: Drip’s if is implemented with TypeScript’s if. The interpreter makes a decision in its own language whenever the program it’s running makes one.

One parsing detail: in if (a) if (b) x; else y; the else belongs to the inner if. The inner ifStatement call parses its then-branch and then greedily takes any else that follows, before the outer one gets a look.

Repeating: while

while has the same shape, and borrows TypeScript’s while (chapter 5)^[2]:

case 'while':
  while (isTruthy(
    this.evaluate(s.condition))) {
    this.execute(s.body);
  }
  return;

The condition is re-evaluated before every trip round the loop, so the body must change something the condition reads, or the loop never stops. (Drip has no break, so the condition is the only way out, for now.)

The loop that isn’t there: for

A for loop packs four things into one line:

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

You could add a fifth kind of statement and a new case to the interpreter. But look at what it means: run the initializer once, then while the condition holds, run the body and then the increment. That is a while loop you already know how to run. So the parser rewrites it into one, and the interpreter never hears the word for:

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

Here is the end of forStatement in parser.ts, lightly simplified (block and exprStmt stand for the plain node objects the real code spells out):

let body = statement();
if (increment) {
  body = block([body,
    exprStmt(increment)]);
}
body = { kind: 'while',
         condition, body };
if (initializer) {
  body = block([initializer, body]);
}
return body;

Each part is optional. With no increment, the body is left alone; with no initializer, there’s no outer block. A missing condition, as in for (;;), becomes the literal true: a loop that runs forever.

The outer block matters. Because it gets its own environment (chapter 37), the loop’s i lives only as long as the loop, and it can shadow an i outside:

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

and, or: operators that skip

and and or look like binary operators, and they sit in the Pratt table with binding powers like the rest (and binds tighter than or). But the binary case evaluates both sides before it looks at the operator. For these two, that’s wrong:

let ok = false and (calls = calls + 1);

Once the left side is false, the answer is known, and the assignment on the right must not happen. So the parser makes a separate logical node, and the interpreter treats it like a tiny if:

case 'logical': {
  const l = this.evaluate(e.left);
  if (e.operator.type === 'or') {
    return isTruthy(l)
      ? l : this.evaluate(e.right);
  }
  return isTruthy(l)
    ? this.evaluate(e.right) : l;
}

Look at what comes back: not true or false, but one of the operand values. nil or "default" is "default", and 1 and 2 is 2. JavaScript’s || and && behave the same way^[3].

let calls = 0;
let ok = false and (calls = calls + 1);
print ok;
print calls;

print nil or "default";
print 1 and 2 and 3;
print 0 or "zero is truthy";

Your turn

The core exercise is the desugaring itself, in plain JavaScript.

function desugarFor(f) {
  // f has init, cond, incr, body.
  // Return a block / while tree.
  return null;
}

// One for loop. Its increment
// doesn't have to add 1.

What you learned

• Control flow is the order statements run in. if runs one branch and while re-checks its condition before every trip, both using truthiness, both borrowed from TypeScript.
• Desugaring rewrites a construct into simpler ones. The parser turns for into { init; while (cond) { body; incr } }, and a missing condition becomes true.
• The outer block keeps the loop variable local to the loop.
• and and or short-circuit: they skip the right side when the left decides, and they return an operand’s value, not a boolean.

Next: functions, the last thing Drip needs before it can run real programs.