Make all functions lambdas for now

src/ast/index.js

 const Attribute = require("./attribute");
 const Boolean = require("./boolean");
 const Identifier = require("./identifier");
-const FunctionDefinition = require("./functionDefinition");
+const Lambda = require("./lambda");
 const List = require("./list");
 const Number = require("./number");
 const String = require("./string");
   Attribute: Attribute,
   Boolean: Boolean,
   Identifier: Identifier,
-  FunctionDefinition: FunctionDefinition,
+  Lambda: Lambda,
   List: List,
   Number: Number,
   String: String,
-  Symbol,
-  Symbol
+  Symbol: Symbol,
 };

src/ast/functionDefinition.js → src/ast/lambda.js

 const Node = require("./node");
 
-module.exports = class FunctionDefinition extends Node {
+module.exports = class Lambda extends Node {
   constructor(opts) {
     super(opts);
   }

src/compiler.js

         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) {
+        } else if (node.function.constructor === AST.Lambda) {
           let env = new Env(this.env)
           node.function.parameters.forEach((param, index) => {
             env.set(param.name, node.args[index])

src/parser.js

 
     let node
 
-    if (this.tokenStream.peek().value === 'define') {
+    if (this.tokenStream.peek().value === 'lambda') {
       this.tokenStream.eat(tokenTypes.IDENTIFIER)
-      node = this.functionDefinition()
-    } else if (this.tokenStream.peek().value === 'lambda') {
-      this.tokenStream.eat(tokenTypes.IDENTIFIER)
-      node = this.functionDefinition(true)
+      node = this.lambda(true)
     } else {
       node = new AST.Application()
 
     })
   }
 
-  functionDefinition(anonymous = false) {
-    let name
-
-    if (anonymous) {
-      name = false
-    } else {
-      name = new AST.Identifier({
-        name: this.tokenStream.eat(tokenTypes.IDENTIFIER).value,
-      })
-    }
-
+  lambda(anonymous = false) {
     let parameters = []
 
     this.tokenStream.eat(tokenTypes.OPAREN)
 
     this.tokenStream.eat(tokenTypes.CPAREN)
 
-    return new AST.FunctionDefinition({
-      name: name,
+    return new AST.Lambda({
       parameters: parameters,
       body: this.form(),
     })

test/parserTest.js

   ])
 })
 
-test('parses calls to define into a function definition', t => {
-  t.plan(1)
-  const tree = helpers.parse('(define plusOne (n) (+ n 1))')
-
-  t.deepEqual(tree, [
-    new AST.FunctionDefinition({
-      name: new AST.Identifier({ name: 'plusOne' }),
-      parameters: [new AST.Identifier({ name: 'n' })],
-      body: new AST.Application({
-        function: new AST.Identifier({ name: '+' }),
-        args: [new AST.Identifier({ name: 'n' }), new AST.Number({ value: 1 })],
-      }),
-    }),
-  ])
-})
-
 test('parse lambdas and expressions in function position', t => {
   t.plan(1)
   const tree = helpers.parse('((lambda (n) (+ n 1)) 5)')
 
   t.deepEqual(tree, [
     new AST.Application({
-      function: new AST.FunctionDefinition({
-        name: false,
+      function: new AST.Lambda({
         parameters: [new AST.Identifier({ name: 'n' })],
         body: new AST.Application({
           function: new AST.Identifier({ name: '+' }),