39. Functions in Drip

Naming a piece of work

Drip can loop and choose now, but every piece of work has to be written out where it’s used. Chapter 1 started JavaScript with the cure for that, and Drip gets it now:

fn add(a, b) {
  print a + b;
}

add(1, 2); // 3
add(3, 4); // 7

Two new pieces of syntax. fn add(a, b) { ... } is a declaration, which the parser turns into a node holding the name, the parameter tokens and the body’s statements. add(1, 2) is a call expression. In the Pratt table, ( is an infix operator with the highest binding power (tied with .): whatever expression is on its left is the callee. So f(1)(2) parses fine: it calls whatever f(1) returns.

A function is a value

Executing the declaration only files the card:

case 'function':
  this.env.define(s.name.lexeme,
    new DripFunction(s, this.env));
  return;

(The real line passes one more argument, a flag that only matters for classes.) A DripFunction holds the declaration node and the environment that was current when it was declared (its closure; chapter 41 is all about why). Then add is defined like any other variable. Functions are first-class runtime values in Drip, just as in JavaScript: you can copy one with let g = add;, and printing one shows <fn add>.

What makes a function special is a single extra ability. In the companion’s runtime.ts, anything you can call has this shape:

interface DripCallable {
  arity(): number;
  call(interp: CallContext,
       args: Value[]): Value;
}

Evaluating a call

Here is the call case of evaluate, with long lines folded:

case 'call': {
  const callee = this.evaluate(e.callee);
  const args = e.args.map(
    (a) => this.evaluate(a));
  if (!isCallable(callee)) {
    throw new RuntimeError(e.paren,
      'Can only call functions ' +
      'and classes.');
  }
  if (args.length !== callee.arity()) {
    throw new RuntimeError(e.paren,
      `Expected ${callee.arity()} ` +
      `arguments but got ${args.length}.`);
  }
  return callee.call(this, args);
}

Evaluate the callee, then the arguments, left to right. Then two checks: is the callee callable at all (123() is not), and does the number of arguments match? Only then is it called. (e.paren is the ) token, kept so the error can report a line.)

And here is what calling a DripFunction does, minus a detail for classes:

call(interp, args) {
  const env = new Environment(
    this.closure);
  this.decl.params.forEach((p, i) =>
    env.define(p.lexeme, args[i]));
  return interp.executeFunctionBody(
    this.decl, env);
}

A brand-new environment, whose parent is the function’s stored environment. Each parameter is defined in it, holding its argument. Then the body runs with that environment as the current one, through the same executeBlock you wrote for blocks. Step through two calls:

let k = 10;
fn add(a, b) {
  let s = a + b;
  print s + k;
}
add(1, 2);
add(3, 4);

Because every call makes its own environment, two calls never share parameters or locals. That’s exactly what recursion needs: each call of a recursive function gets its own n.

Notice too which environment is the parent: the one where the function was declared, not the one it’s called from. That is lexical scope from chapter 6, and you can see it in this example:

fn show() {
  print x;
}

let x = "global";
{
  let x = "local";
  show();
}

Arity

JavaScript is far more relaxed. It reports a function’s expected count as f.length^[3], but doesn’t enforce it. A missing argument just makes the parameter undefined, and extra ones are quietly kept aside^[2]. Drip chooses to fail loudly, which catches a forgotten argument at the call that forgot it.

Native functions

Some things can’t be written in Drip at all. Drip has no way to read the time: no expression or statement asks the outside world anything. So the interpreter supplies one ready-made function, written in TypeScript:

class NativeFunction {
  constructor(n, fn) { ... }
  arity() { return this.n; }
  call(_, args) {
    return this.fn(args);
  }
}

// in the Interpreter constructor:
this.globals.define('clock',
  new NativeFunction(0, () =>
    performance.now() / 1000));

clock() returns seconds as a number, from JavaScript’s performance.now(), a high-resolution timer in milliseconds^[5]. From Drip’s side it’s an ordinary global holding a callable: clock() passes the same two checks as add(1, 2). Printing it shows <native fn>.

print clock;

let start = clock();
let sum = 0;
for (let i = 0; i < 100000; i = i + 1) {
  sum = sum + i;
}
print sum;
print clock() - start;

Your turn

function makeNative(n, fn) {
  // your code here
}

function callValue(callee, args) {
  // your code here
}

const add = makeNative(2,
  (xs) => xs[0] + xs[1]);
console.log(callValue(add, [1, 2]));

// declare square here

for (let i = 1; i <= 5; i = i + 1) {
  square(i);
}

What you learned

• Executing fn doesn’t run anything: it makes a function value holding the declaration and its environment, and defines the name.
• A callable is a value with arity() and call(). A call expression evaluates the callee and the arguments, checks that the callee is callable and that the arity matches, then calls it.
• Calling a Drip function makes a fresh environment whose parent is the function’s own, defines the parameters there, and runs the body in it.
• A native function is implemented in the host language, like clock. It’s how Drip reaches outside itself.

Next: return, and how the interpreter escapes from deep inside a body.