feat: treat functions as values

src/__tests__/interpreter.test.js

@@ -279,6 +279,10 @@ const tests = [
     sourceCode: `($x + $foobar | [$, $foobar]) where $x = 3 $foobar = ($x + 1)`,
     input: 4,
     output: [7, 4]
+  },
+  {
+    sourceCode: `([1] | map $foo | $[0]) where $foo = ($ => 4)`,
+    output: 4
   }
 ]
 

src/generators/__tests__/lambda.test.js

@@ -0,0 +1,27 @@
+import lambda from '../lambda'
+
+describe('lambda generator', () => {
+  it('returns correct code', () => {
+    expect(
+      lambda({
+        name: 'lambda',
+        value: {
+          name: 'primitive',
+          value: '4'
+        }
+      })
+    ).toEqual(`(function(input) {return 4})`)
+  })
+
+  it('returns correct code', () => {
+    expect(
+      lambda({
+        name: 'lambda',
+        value: {
+          name: 'primitive',
+          value: '8'
+        }
+      })
+    ).toEqual(`(function(input) {return 8})`)
+  })
+})

src/generators/generator.js

@@ -11,10 +11,10 @@ import object from './object'
 import projection from './projection'
 import pipe from './pipe'
 import functionCall from './functionCall'
-import functionCallLambda from './functionCallLambda'
 import binaryOperator from './binaryOperator'
 import unaryOperator from './unaryOperator'
 import assignment from './assignment'
+import lambda from './lambda'
 import variable from './variable'
 import type { NodeType, GeneratedCodeType } from '../types'
 
@@ -44,8 +44,8 @@ const Generator = (node: NodeType): GeneratedCodeType => {
       return projection(Generator)(node)
     case 'functionCall':
       return functionCall(Generator)(node)
-    case 'functionCallLambda':
-      return functionCallLambda(Generator)(node)
+    case 'lambda':
+      return lambda(node)
     case 'binaryOperation':
       return binaryOperator(node)
     case 'unaryOperation':

src/generators/lambda.js

@@ -0,0 +1,9 @@
+// @flow
+
+import type { LambdaNodeType, GeneratedCodeType } from '../types'
+
+export default ({ value }: LambdaNodeType): GeneratedCodeType =>
+  `(function(input) {return ${((): GeneratedCodeType => {
+    const Generator = require('./generator').default
+    return Generator(value)
+  })()}})`

src/parsers/__tests__/lambda.test.js

@@ -0,0 +1,23 @@
+import parser from '../lambda'
+
+describe('lambda parser', () => {
+  it('parses correct string - syntax 1', () => {
+    expect(parser.parse(`$ => 3 + 4`).status).toBe(true)
+    expect(parser.parse(`$ => 1`).status).toBe(true)
+  })
+
+  it('parses correct string - syntax 2', () => {
+    expect(parser.parse(`\\3 + 4`).status).toBe(true)
+    expect(parser.parse(`\\1`).status).toBe(true)
+  })
+
+  it('returns correct string', () => {
+    expect(parser.parse('$ => 4').value).toMatchObject({
+      name: 'lambda',
+      value: {
+        name: 'primitive',
+        value: '4'
+      }
+    })
+  })
+})

src/parsers/assignment.js

@@ -1,7 +1,7 @@
 // @flow
 
 import P from 'parsimmon'
-import OperandParser from './operand'
+import SectionParser from './section'
 import IdentifierParser from './identifier'
 import TupleParser from './tuple/tuple'
 import crap from './crap'
@@ -16,7 +16,7 @@ const Assignment = P.seq(
   P.string('$').then(IdentifierParser),
   P.string('=')
     .trim(crap)
-    .then(OperandParser)
+    .then(SectionParser)
 )
 
 const Assignments = P.sepBy(Assignment, crap)

src/parsers/lambda.js

@@ -0,0 +1,18 @@
+// @flow
+
+import P from 'parsimmon'
+import crap from './crap'
+import TupleParser from './tuple/tuple'
+
+export default P.alt(
+  P.string('$')
+    .then(crap)
+    .then(P.string('=>'))
+    .then(crap)
+    .then(TupleParser),
+  P.string('\\')
+    .then(crap)
+    .then(TupleParser)
+)
+  .trim(crap)
+  .node('lambda')

src/parsers/section.js

@@ -1,10 +1,8 @@
 import P from 'parsimmon'
 import FunctionCallParser from './functionCall'
-import FunctionCallLambdaParser from './functionCallLambda'
 import Boolean3Parser from './boolean3'
 
 export default P.alt(
-  FunctionCallLambdaParser,
   FunctionCallParser,
   Boolean3Parser
 )

src/parsers/value.js

@@ -6,11 +6,13 @@ import InputPropParser from './inputProp'
 import ListParser from './list'
 import ParenthesesParser from './parentheses'
 import VariableParser from './variable'
+import LambdaParser from './lambda'
 
 export default P.alt(
   PrimitiveParser,
   InputPropParser,
   VariableParser,
+  LambdaParser,
   InputParser,
   ListParser,
   ParenthesesParser

src/types.js

@@ -96,12 +96,9 @@ export type FunctionCallNodeType = {|
   }
 |};
 
-export type FunctionCallLambdaNodeType = {|
-  name: 'functionCallLambda',
-  value: {
-    left: IdentifierNodeType,
-    right: NodeType // eslint-disable-line no-use-before-define
-  }
+export type LambdaNodeType = {|
+  name: 'lambda',
+  value: NodeType // eslint-disable-line no-use-before-define
 |};
 
 export type ProjectionNodeType = {|
@@ -151,7 +148,7 @@ export type NodeType =
   | ObjectNodeType
   | ValuePropNodeType
   | FunctionCallNodeType
-  | FunctionCallLambdaNodeType
+  | LambdaNodeType
   | OperationNodeType
   | UnaryOperationNodeType
   | ProjectionNodeType;