Evaluate lambda functions

src/evaluator.js

@@ -14,11 +14,34 @@ module.exports = class Evaluator {
 
   evalNode(node, env) {
     switch (node.constructor) {
+      case AST.Number:
+        return node
+      case AST.Identifier:
+        return env.get(node.name)
       case AST.Application:
         switch (node.function.constructor) {
           case AST.Identifier:
-            node.function = env.get(node.function.name)
-            break
+            return this.evalNode(
+              new AST.Application({
+                function: env.get(node.function.name),
+                args: node.args,
+              }),
+              env
+            )
+          case AST.Lambda:
+            let innerEnv = new Env()
+
+            node.function.parameters.forEach((param, index) => {
+              innerEnv.set(param.name, node.args[index])
+            })
+
+            return this.evalNode(node.function.body, innerEnv)
+          case Function:
+            let args = node.args.map(arg => {
+              return this.evalNode(arg, env)
+            })
+            args.unshift(this)
+            return node.function.call(...args)
         }
     }
 

test/evaluatorTest.js

@@ -4,18 +4,18 @@ 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)
+test('applies functions from core library', t => {
+  t.plan(1)
 
   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 })
-  )
+  t.deepEqual(tree[0], new AST.Number({ value: 3 }))
+})
+
+test('applies lambda functions', t => {
+  t.plan(1)
+
+  const tree = helpers.evaluate('((lambda (x y) (+ x y)) 1 2)')
+
+  t.deepEqual(tree[0], new AST.Number({ value: 3 }))
 })