Implement definitions

src/ast/definition.js

+const Node = require('./node')
+
+module.exports = class Definition extends Node {
+  constructor(opts) {
+    super(opts)
+  }
+}

src/ast/index.js

 const Attribute = require("./attribute");
 const Boolean = require("./boolean");
 const Conditional = require('./conditional')
+const Definition = require('./definition')
 const Identifier = require("./identifier");
 const Lambda = require("./lambda");
 const List = require("./list");
   Attribute: Attribute,
   Boolean: Boolean,
   Conditional: Conditional,
+  Definition: Definition,
   Identifier: Identifier,
   Lambda: Lambda,
   List: List,

src/evaluator.js

 
 module.exports = class Evaluator {
   eval(tree, env) {
+    this.env = env
+
     let evaluatedTree = []
 
     tree.forEach(node => {
-      evaluatedTree.push(this.evalNode(node, env))
+      let evaluatedNode = this.evalNode(node)
+
+      if (evaluatedNode) {
+        evaluatedTree.push(evaluatedNode)
+      }
     })
 
     return evaluatedTree
   }
 
   evalNode(node, env) {
+    if (!env) env = this.env
+
     switch (node.constructor) {
       case AST.Boolean:
       case AST.Number:
         return node
       case AST.Identifier:
         return env.get(node.name)
+      case AST.Definition:
+        this.env.set(node.symbol.name, node.value)
+        return false
       case AST.Application:
         switch (node.function.constructor) {
           case AST.Identifier:
                 function: env.get(node.function.name),
                 args: node.args,
               }),
-              env
             )
           case AST.Lambda:
-            let innerEnv = new Env()
+            let innerEnv = new Env(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)
+              return this.evalNode(arg)
             })
             args.unshift(this)
             return node.function.call(...args)

src/parser.js

     if (this.tokenStream.peek().value === 'lambda') {
       this.tokenStream.eat(tokenTypes.IDENTIFIER)
       node = this.lambda()
+    } else if (this.tokenStream.peek().value === 'define') {
+      this.tokenStream.eat(tokenTypes.IDENTIFIER)
+      node = this.definition()
     } else if (this.tokenStream.peek().value === 'if') {
       this.tokenStream.eat(tokenTypes.IDENTIFIER)
       node = this.conditional()
     })
   }
 
+  definition() {
+    return new AST.Definition({
+      symbol: this.identifier(),
+      value: this.expr(),
+    })
+  }
+
   lambda() {
     let parameters = []
 

test/evaluatorTest.js

   t.plan(1)
 
   const tree = helpers.evaluate('(+ 1 2)')
-
   t.deepEqual(tree[0], new AST.Number({ value: 3 }))
 })
 
   t.plan(1)
 
   const tree = helpers.evaluate('((lambda (x y) (+ x y)) 1 2)')
-
   t.deepEqual(tree[0], new AST.Number({ value: 3 }))
 })
+
+test('define', t => {
+  t.plan(2)
+
+  let tree = helpers.evaluate('(define x 5) (+ x 1)')
+  t.deepEqual(tree[0], new AST.Number({ value: 6 }))
+
+  tree = helpers.evaluate('(define plusOne (lambda (x) (+ x 1))) (plusOne 5)')
+  t.deepEqual(tree[0], new AST.Number({ value: 6 }))
+})