septima-lang 0.0.5 → 0.0.6

package/tests/septima.spec.ts

@@ -16,7 +16,7 @@ function run(input: string) {
  */
 function runSink(input: string) {
   const septima = new Septima()
-  const res = septima.compute(input)
+  const res = septima.compute(input, {}, 'quiet', {})
 
   if (res.tag !== 'sink') {
     throw new Error(`Not a sink: ${res.value}`)
@@ -431,6 +431,10 @@ describe('septima', () => {
       expect(run(`let triple = (fun(a) 3*a); triple(100) - triple(90)`)).toEqual(30)
       expect(run(`let triple = fun(a) 3*a; triple(100) - triple(90)`)).toEqual(30)
     })
+    test('allows a dangling comma, at the call site, after the last actual argument', () => {
+      expect(run(`let triple = (fun(a) 3*a); triple(100,)`)).toEqual(300)
+      expect(run(`let mean = (fun(a,b) (a+b)/2); mean(4, 28,)`)).toEqual(16)
+    })
     describe('arrow function notation', () => {
       test('a single formal argument does not need to be surrounded with parenthesis', () => {
         expect(run(`let triple = a => 3*a; triple(100)`)).toEqual(300)
@@ -462,7 +466,7 @@ describe('septima', () => {
       expect(run(`let pi = fun() 3.14; 2*pi()`)).toEqual(6.28)
       expect(run(`(fun() 3.14)()*2`)).toEqual(6.28)
     })
-    test('error on arg list mismatch', () => {
+    test('errors on arg list mismatch', () => {
       expect(() => run(`let quadSum = fun(a,b,c,d) a+b+c+d; quadSum(4,8,2)`)).toThrowError(
         'Arg list length mismatch: expected 4 but got 3',
       )
@@ -522,6 +526,9 @@ describe('septima', () => {
       expect(run(`let f = fun (a) if (a > 0) a else sink; 2+f(-1)+4`)).toEqual(undefined)
       expect(run(`let f = fun (a) if (a > 0) a else sink; 2+f(3)+4`)).toEqual(9)
     })
+    test('the "undefined" literal is an alias for "sink"', () => {
+      expect(run(`let x = sink; 5+8+9+x+20+30`)).toEqual(undefined)
+    })
     test('an array can hold a sink without becoming a sink itself', () => {
       expect(run(`let f = fun (a) if (a > 0) a else sink; [f(1), f(-1), f(8)]`)).toEqual([1, undefined, 8])
     })
@@ -621,6 +628,13 @@ describe('septima', () => {
         ].join('\n'),
       )
     })
+    test(`can also appear in code as undefined!`, () => {
+      expect(runSink(`1000 + undefined!`).trace).toEqual(
+        [`  at (1:1..17) 1000 + undefined!`, `  at (1:1..17) 1000 + undefined!`, `  at (1:8..17) undefined!`].join(
+          '\n',
+        ),
+      )
+    })
   })
   describe('sink!!', () => {
     test(`captures the expression trace and the symbol-table at runtime`, () => {
@@ -631,7 +645,7 @@ describe('septima', () => {
         x: 30,
         y: 40,
       })
-      expect(Object.keys(actual.symbols ?? {})).toEqual(['Object', 'a', 'f', 'x', 'y'])
+      expect(Object.keys(actual.symbols ?? {})).toEqual(['Object', 'args', 'a', 'f', 'x', 'y'])
       expect(actual.trace).toEqual(
         [
           `  at (1:1..58) let a = 2; let f = fun(x, y) x * y * sink!! * a; f(30, 40)`,
@@ -649,6 +663,11 @@ describe('septima', () => {
         n: -3,
       })
     })
+    test(`can also appear in code as undefined!!`, () => {
+      expect(runSink(`let f = fun (n) undefined!!; f(18)`).symbols).toMatchObject({
+        n: 18,
+      })
+    })
   })
 
   describe('array methods', () => {
@@ -803,7 +822,7 @@ describe('septima', () => {
       const preimports = {
         libA: `{ plus10: fun (n) n+10, plus20: fun (n) n+20}`,
       }
-      expect(septima.compute(input, preimports)).toMatchObject({ value: 36 })
+      expect(septima.compute(input, preimports, 'quiet', {})).toMatchObject({ value: 36 })
     })
     test('supports multiple preimports', () => {
       const septima = new Septima()
@@ -813,13 +832,35 @@ describe('septima', () => {
         a: `{ calc: fun (n) n+10 }`,
         b: `{ calc: fun (n) n+20 }`,
       }
-      expect(septima.compute(input, preimports)).toMatchObject({ value: 35 })
+      expect(septima.compute(input, preimports, 'quiet', {})).toMatchObject({ value: 35 })
+    })
+  })
+  describe('args', () => {
+    test('are bounded at runtime to a special variable called "args"', () => {
+      const septima = new Septima()
+      expect(
+        septima.compute(`args.a + '_' + args.color[0] + '_' + args.b + '_' + args.color[1]`, {}, 'quiet', {
+          a: 'Sunday',
+          b: 'Monday',
+          color: ['Red', 'Green'],
+        }),
+      ).toMatchObject({ value: 'Sunday_Red_Monday_Green' })
+    })
+    test('are shadowed by a program-defined "args" symbol', () => {
+      const septima = new Septima()
+      expect(
+        septima.compute(`let args = {color: 'Green' }; args.color`, {}, 'quiet', {
+          color: 'Red',
+        }),
+      ).toMatchObject({ value: 'Green' })
+    })
+    test('are supported also via the Septima.run() API', () => {
+      expect(Septima.run(`args.a + args.b`, undefined, { a: 100, b: 2 })).toEqual(102)
     })
   })
   test.todo('support file names in locations')
   test.todo('string interpolation via `foo` strings')
   test.todo('imports')
-  test.todo('arrow functions')
   test.todo('optional parameters')
   test.todo('optional type annotations?')
   test.todo('allow redundant commas')