Replace compiler with evaluator

This class exposes two functions. `evalNode` take an AST node and evaluates it down to simplest terms. `eval` takes an array of AST nodes and calls evalNode on each of them. I don’t think we’re quite ready to be producing HTML yet so let’s not get ahead of ourselves.

src/compiler.js

@@ -1,57 +0,0 @@
-const AST = require('./ast')
-const Env = require('./env')
-
-module.exports = class Compiler {
-  constructor(env = null) {
-    this.result = ''
-
-    if (env) {
-      this.env = env
-    } else {
-      this.env = new Env()
-    }
-  }
-
-  compile(tree) {
-    tree.forEach(node => {
-      this.result += this.compileNode(node)
-    })
-
-    return this.result
-  }
-
-  compileNode(node) {
-    switch (node.constructor) {
-      case AST.Number:
-      case AST.String:
-        return node.value
-      case AST.Boolean:
-        return node.value === true ? '#t' : '#f'
-      case AST.Identifier:
-        return this.compileNode(this.env.get(node.name))
-      case AST.Conditional:
-        let condition = this.compileNode(node.condition)
-
-        if (condition) {
-          return this.compileNode(node.ifCase)
-        } else {
-          return this.compileNode(node.elseCase)
-        }
-      case AST.Application:
-        if (node.function.constructor === AST.Identifier) {
-          let f = this.env.get(node.function.name)
-          return this.compileNode(f(...node.args.map(arg => this.compileNode(arg))))
-        } else if (node.function.constructor === AST.Lambda) {
-          let env = new Env(this.env)
-          node.function.parameters.forEach((param, index) => {
-            env.set(param.name, node.args[index])
-          })
-
-          let compiler = new Compiler(env)
-          return compiler.compileNode(node.function.body)
-        }
-
-        return ''
-    }
-  }
-}

src/env.js

@@ -6,15 +6,15 @@ module.exports = class Env {
       this.data = parent.data
     } else {
       this.data = {
-        '+': (a, b) => new AST.Number({ value: a + b }),
-        '-': (a, b) => new AST.Number({ value: a - b }),
-        '*': (a, b) => new AST.Number({ value: a * b }),
-        '/': (a, b) => new AST.Number({ value: a / b }),
-        '=': (a, b) => new AST.Boolean({ value: a === b }),
-        '>': (a, b) => new AST.Boolean({ value: a > b }),
-        '<': (a, b) => new AST.Boolean({ value: a < b }),
-        '>=': (a, b) => new AST.Boolean({ value: a >= b }),
-        '<=': (a, b) => new AST.Boolean({ value: a <= b }),
+        '+': (a, b) => new AST.Number({ value: a.value + b.value }),
+        '-': (a, b) => new AST.Number({ value: a.value - b.value }),
+        '*': (a, b) => new AST.Number({ value: a.value * b.value }),
+        '/': (a, b) => new AST.Number({ value: a.value / b.value }),
+        '=': (a, b) => new AST.Boolean({ value: a.value === b.value }),
+        '>': (a, b) => new AST.Boolean({ value: a.value > b.value }),
+        '<': (a, b) => new AST.Boolean({ value: a.value < b.value }),
+        '>=': (a, b) => new AST.Boolean({ value: a.value >= b.value }),
+        '<=': (a, b) => new AST.Boolean({ value: a.value <= b.value }),
       }
     }
   }

src/evaluator.js

@@ -0,0 +1,27 @@
+const AST = require('./ast')
+const Env = require('./env')
+
+module.exports = class Evaluator {
+  eval(tree, env) {
+    let evaluatedTree = []
+
+    tree.forEach(node => {
+      evaluatedTree.push(this.evalNode(node, env))
+    })
+
+    return evaluatedTree
+  }
+
+  evalNode(node, env) {
+    switch (node.constructor) {
+      case AST.Application:
+        switch (node.function.constructor) {
+          case AST.Identifier:
+            node.function = env.get(node.function.name)
+            break
+        }
+    }
+
+    return node
+  }
+}

src/index.js

@@ -1,4 +1,5 @@
-const Compiler = require('./compiler')
+const Env = require('./env')
+const Evaluator = require('./evaluator')
 const Lexer = require('./lexer')
 const Parser = require('./parser')
 
@@ -6,11 +7,11 @@ module.exports = function oslo(source, context) {
   const lexer = new Lexer()
   const tokens = lexer.scan(source)
 
-  const parser = new Parser(tokens)
-  const tree = parser.parse()
+  const parser = new Parser()
+  const tree = parser.parse(tokens)
 
-  const compiler = new Compiler()
-  const result = compiler.compile(tree)
+  const evaluator = new Evaluator()
+  const evaluatedTree = evaluator.eval(tree, new Env())
 
-  return result
+  return ''
 }

src/parser.js

@@ -3,11 +3,8 @@ const Error = require('./Error')
 const tokenTypes = require('./tokenTypes')
 
 module.exports = class Parser {
-  constructor(tokenStream) {
+  parse(tokenStream) {
     this.tokenStream = tokenStream
-  }
-
-  parse() {
     let tree = []
     while (this.tokenStream.peek().type !== tokenTypes.EOF) {
       let expr = this.expr()

test/compilerTest.js

@@ -1,46 +0,0 @@
-const test = require('tape')
-const helpers = require('./helpers')
-
-const AST = require('../src/ast')
-
-test('compiles numbers', t => {
-  t.plan(1)
-
-  const result = helpers.compile('5')
-
-  t.equal(result, '5')
-})
-
-test('compiles strings', t => {
-  t.plan(1)
-
-  const result = helpers.compile('"hello world"')
-
-  t.equal(result, 'hello world')
-})
-
-test('compiles core function applications', t => {
-  t.plan(4)
-
-  let result = helpers.compile('(+ 10 8)')
-  t.equal(result, '18')
-
-  result = helpers.compile('(- 7 3)')
-  t.equal(result, '4')
-
-  result = helpers.compile('(* 9 3)')
-  t.equal(result, '27')
-
-  result = helpers.compile('(/ 10 2)')
-  t.equal(result, '5')
-})
-
-test('compiles lambda expressions in the function position', t => {
-  t.plan(2)
-
-  let result = helpers.compile('((lambda (x) (+ x 1)) 2)')
-  t.equal(result, '3')
-
-  result = helpers.compile('((lambda (x y) (+ x y)) 2 3)')
-  t.equal(result, '5')
-})

test/coreTest.js

@@ -1,21 +0,0 @@
-const test = require('tape')
-const helpers = require('./helpers')
-
-test('comparison functions', t => {
-  t.plan(5)
-
-  let result = helpers.compile('(= 1 2)')
-  t.equal(result, '#f')
-
-  result = helpers.compile('(> 5 4)')
-  t.equal(result, '#t')
-
-  result = helpers.compile('(< 58 10)')
-  t.equal(result, '#f')
-
-  result = helpers.compile('(>= 5 5)')
-  t.equal(result, '#t')
-
-  result = helpers.compile('(<= 10 10)')
-  t.equal(result, '#t')
-})

test/evaluatorTest.js

@@ -0,0 +1,21 @@
+const test = require('tape')
+const helpers = require('./helpers')
+
+const AST = require('../src/ast')
+const Evaluator = require('../src/evaluator')
+
+test('looks up and injects the function to which a symbol refers', t => {
+  t.plan(2)
+
+  const tree = helpers.evaluate('(+ 1 2)')
+
+  t.deepEqual(tree[0].function.constructor, Function)
+  t.deepEqual(
+    tree[0].function.call(
+      this,
+      new AST.Number({ value: 4 }),
+      new AST.Number({ value: 5 })
+    ),
+    new AST.Number({ value: 9 })
+  )
+})

test/helpers.js

@@ -1,4 +1,5 @@
-const Compiler = require('../src/compiler')
+const Env = require('../src/env')
+const Evaluator = require('../src/evaluator')
 const Lexer = require('../src/lexer')
 const Parser = require('../src/parser')
 
@@ -8,17 +9,19 @@ const scan = source => {
 }
 
 const parse = source => {
-  const parser = new Parser(scan(source))
-  return parser.parse()
+  const parser = new Parser()
+  return parser.parse(scan(source))
 }
 
-const compile = source => {
-  const compiler = new Compiler()
-  return compiler.compile(parse(source))
+const evaluate = source => {
+  const evaluator = new Evaluator()
+  return evaluator.eval(parse(source), new Env())
 }
 
 module.exports = {
-  compile: compile,
+  evaluate: evaluate,
   parse: parse,
   scan: scan,
 }
+
+console.log(evaluate('(+ 1 2)'))

test/parserTest.js

@@ -82,16 +82,12 @@ test('parse conditionals', t => {
       condition: new AST.Boolean({ value: true }),
       ifCase: new AST.Application({
         function: new AST.Identifier({ name: 'do' }),
-        args: [
-          new AST.Identifier({ name: 'this' })
-        ]
+        args: [new AST.Identifier({ name: 'this' })],
       }),
       elseCase: new AST.Application({
         function: new AST.Identifier({ name: 'do' }),
-        args: [
-          new AST.Identifier({ name: 'that' })
-        ]
+        args: [new AST.Identifier({ name: 'that' })],
       }),
-    })
+    }),
   ])
 })