Add lambdas

src/parser.js

 
     if (this.tokenStream.peek().value === 'define') {
       this.tokenStream.eat(tokenTypes.IDENTIFIER)
-
       node = this.functionDefinition()
+    } else if (this.tokenStream.peek().value === 'lambda') {
+      this.tokenStream.eat(tokenTypes.IDENTIFIER)
+      node = this.functionDefinition(true)
     } else {
       node = new AST.Application()
 
-      node.functionName = this.identifier()
+      node.function = this.expr()
+
       node.args = []
 
       while (this.tokenStream.peek().type !== tokenTypes.CPAREN) {
     })
   }
 
-  functionDefinition() {
-    let name = new AST.Identifier({
-      name: this.tokenStream.eat(tokenTypes.IDENTIFIER).value,
-    })
+  functionDefinition(anonymous = false) {
+    let name
+
+    if (anonymous) {
+      name = false
+    } else {
+      name = new AST.Identifier({
+        name: this.tokenStream.eat(tokenTypes.IDENTIFIER).value,
+      })
+    }
 
     let parameters = []
 

test/parserTest.js

 
   t.deepEqual(tree, [
     new AST.Application({
-      functionName: new AST.Identifier({ name: 'div' }),
+      function: new AST.Identifier({ name: 'div' }),
       args: [
         new AST.Attribute({
           name: 'class',
           value: new AST.String({ value: 'foobar' }),
         }),
         new AST.Application({
-          functionName: new AST.Identifier({ name: 'p' }),
+          function: new AST.Identifier({ name: 'p' }),
           args: [
             new AST.Attribute({
               name: 'class',
               value: new AST.Application({
-                functionName: new AST.Identifier({ name: 'cond' }),
+                function: new AST.Identifier({ name: 'cond' }),
                 args: [
                   new AST.Boolean({ value: true }),
                   new AST.String({ value: 'primary' }),
 
   t.deepEqual(tree, [
     new AST.Application({
-      functionName: new AST.Identifier({ name: 'p' }),
+      function: new AST.Identifier({ name: 'p' }),
       args: [new AST.String({ value: '' })],
     }),
   ])
       name: new AST.Identifier({ name: 'plusOne' }),
       parameters: [new AST.Identifier({ name: 'n' })],
       body: new AST.Application({
-        functionName: new AST.Identifier({ name: '+' }),
+        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,
+        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 })],
+        }),
+      }),
+      args: [
+        new AST.Number({ value: 5 })
+      ]
+    })
+  ])
+})