untyped-tagless-final-interpreters.js

const createOperation = name => (...args) => {
  let operation = interpreter =>
    interpreter[name](
      ...args.map(f => (f && f.operation ? f(interpreter) : f))
    );
  operation.operation = true;
  return operation;
};

const createOperations = (...names) =>
  names.reduce(
    (operations, name) => ({ ...operations, [name]: createOperation(name) }),
    {}
  );

const { abs, app, int, add, mul } = createOperations(
  "abs",
  "app",
  "int",
  "add",
  "mul"
);

const runExpr = (expr, interpreter) => expr(interpreter);

const expr = app(
  abs(n => n - 14),
  mul(int(2), add(int(3), int(4)))
);

const astBuilder = {
  abs: f => ({ type: "FunctionDefinition", f }),
  app: (f, ...args) => ({ type: "FunctionApplication", f, args }),
  int: n => ({ type: "NumberLiteral", value: n }),
  add: (a, b) => ({ type: "NumberAddition", left: a, right: b }),
  mul: (a, b) => ({ type: "NumberMultiplication", left: a, right: b })
};

const evaluator = {
  abs: f => f,
  app: (f, ...args) => f(...args),
  int: n => n,
  add: (a, b) => a + b,
  mul: (a, b) => a * b
};

const printer = {
  abs: f => f.toString(),
  app: (f, ...args) => `(${f})(${args.join(", ")})`,
  int: n => `${n}`,
  add: (a, b) => `(${a} + ${b})`,
  mul: (a, b) => `(${a} * ${b})`
};

console.log("ast", runExpr(expr, astBuilder));
console.log("result", runExpr(expr, evaluator));
console.log("print", runExpr(expr, printer));