Compile function applications (named and lambda)

src/compiler.js

@@ -1,8 +1,15 @@
 const AST = require('./ast')
+const Env = require('./env')
 
 module.exports = class Compiler {
-  constructor() {
+  constructor(env = null) {
     this.result = ''
+
+    if (env) {
+      this.env = env
+    } else {
+      this.env = new Env()
+    }
   }
 
   compile(tree) {
@@ -18,6 +25,24 @@ module.exports = class Compiler {
       case AST.Number:
       case AST.String:
         return node.value
+      case AST.Identifier:
+        return this.compileNode(this.env.get(node.name))
+      case AST.Application:
+
+        if (node.function.constructor === AST.Identifier) {
+          let f = this.env.get(node.function.name)
+          return f(...node.args.map(arg => this.compileNode(arg)))
+        } else if (node.function.constructor === AST.FunctionDefinition) {
+          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

@@ -0,0 +1,26 @@
+module.exports = class Env {
+  constructor(parent = null) {
+    if (parent) {
+      this.data = parent.data
+    } else {
+      this.data = {
+        '+': (a, b) => a + b,
+        '-': (a, b) => a - b,
+        '*': (a, b) => a * b,
+        '/': (a, b) => a / b,
+      }
+    }
+  }
+
+  get(symbol) {
+    if (this.data[symbol]) {
+      return this.data[symbol]
+    }
+
+    throw `Symbol ${symbol} is not bound`
+  }
+
+  set(symbol, value) {
+    this.data[symbol] = value
+  }
+}

test/compilerTest.js

@@ -18,3 +18,29 @@ test('compiles strings', t => {
 
   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')
+})