Implement let bindings

src/ast.js

   Definition: class Definition extends Node {},
   Identifier: class Identifier extends Node {},
   Lambda: class Lambda extends Node {},
+  LetBinding: class LetBinding extends Node {},
   List: class List extends Node {},
   Number: class Number extends Node {},
   String: class String extends Node {},

src/evaluator.js

       }
     })
 
-    console.log(
-      require('util').inspect(evaluatedTree, { depth: null })
-    )
-
     return evaluatedTree
   }
 
       case AST.Definition:
         this.env.set(node.symbol.name, node.value)
         return false
+      case AST.LetBinding:
+        let innerEnv = new Env(env)
+
+        node.bindings.forEach(binding => {
+          innerEnv.set(binding.key.name, binding.value)
+        })
+
+        return this.evalNode(node.body, innerEnv)
       case AST.Conditional:
         let result = this.evalNode(node.condition, env)
 

src/parser.js

     } else if (this.tokenStream.peek().value === 'if') {
       this.tokenStream.eat(tokenTypes.IDENTIFIER)
       node = this.conditional()
+    } else if (this.tokenStream.peek().value === 'let') {
+      this.tokenStream.eat(tokenTypes.IDENTIFIER)
+      node = this.let()
     } else {
       node = new AST.Application()
 
     })
   }
 
+  let() {
+    let bindings = []
+
+    this.tokenStream.eat(tokenTypes.OPAREN)
+
+    while (this.tokenStream.peek().type !== tokenTypes.CPAREN) {
+      this.tokenStream.eat(tokenTypes.OPAREN)
+      bindings.push({
+        key: new AST.Identifier({
+          name: this.tokenStream.eat(tokenTypes.IDENTIFIER).value,
+        }),
+        value: this.expr(),
+      })
+      this.tokenStream.eat(tokenTypes.CPAREN)
+    }
+
+    this.tokenStream.eat(tokenTypes.CPAREN)
+
+    return new AST.LetBinding({
+      bindings: bindings,
+      body: this.expr(),
+    })
   }
 
   number() {

test/evaluatorTest.js

   tree = helpers.evaluate('(if (= (+ 4 9) (- 20 7)) (+ 10 9) (- 4 2))')
   t.deepEqual(tree[0], new AST.Number({ value: 19 }))
 })
+
+test('let bindings', t => {
+  t.plan(1)
+
+  const tree = helpers.evaluate('(let ((x 1) (y 2)) (+ x y))')
+  t.deepEqual(tree[0], new AST.Number({ value: 3 }))
+})