Implement conditionals

Currently I'm relying on JavaScript's semantics
around truthiness. I think I'm going to retain
that ease of use (i.e. `(if list #t #f)` should
return true if the list has more than 0 elements,
etc) but I want to specify that behavior myself.

src/ast/conditional.js

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

src/ast/index.js

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

src/compiler.js

         return node.value
       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)

src/parser.js

 
     if (this.tokenStream.peek().value === 'lambda') {
       this.tokenStream.eat(tokenTypes.IDENTIFIER)
-      node = this.lambda(true)
+      node = this.lambda()
+    } else if (this.tokenStream.peek().value === 'if') {
+      this.tokenStream.eat(tokenTypes.IDENTIFIER)
+      node = this.conditional()
     } else {
       node = new AST.Application()
 
     })
   }
 
+  conditional() {
+    return new AST.Conditional({
+      condition: this.expr(),
+      ifCase: this.expr(),
+      elseCase: this.expr(),
+    })
+  }
+
   lambda() {
     let parameters = []
 

test/parserTest.js

     }),
   ])
 })
+
+test('parse conditionals', t => {
+  t.plan(1)
+  const tree = helpers.parse('(if #t (do this) (do that))')
+
+  t.deepEqual(tree, [
+    new AST.Conditional({
+      condition: new AST.Boolean({ value: true }),
+      ifCase: new AST.Application({
+        function: new AST.Identifier({ name: 'do' }),
+        args: [
+          new AST.Identifier({ name: 'this' })
+        ]
+      }),
+      elseCase: new AST.Application({
+        function: new AST.Identifier({ name: 'do' }),
+        args: [
+          new AST.Identifier({ name: 'that' })
+        ]
+      }),
+    })
+  ])
+})