septima-lang 0.0.3 → 0.0.6

package/tests/septima.spec.ts

@@ -15,8 +15,8 @@ function run(input: string) {
  * @param input the Septima program to run
  */
 function runSink(input: string) {
-  const septima = new Septima(input)
-  const res = septima.compute()
+  const septima = new Septima()
+  const res = septima.compute(input, {}, 'quiet', {})
 
   if (res.tag !== 'sink') {
     throw new Error(`Not a sink: ${res.value}`)
@@ -84,6 +84,7 @@ describe('septima', () => {
     const expected = [
       `value type error: expected num but found "zxcvbnm" when evaluating:`,
       `  at (1:1..21) 9 * 8 * 'zxcvbnm' * 7`,
+      `  at (1:1..21) 9 * 8 * 'zxcvbnm' * 7`,
       `  at (1:5..21) 8 * 'zxcvbnm' * 7`,
       `  at (1:10..21) zxcvbnm' * 7`,
     ].join('\n')
@@ -270,6 +271,12 @@ describe('septima', () => {
       expect(run(`["ab", 5]`)).toEqual(['ab', 5])
       expect(run(`[]`)).toEqual([])
     })
+    test('allow a dangling comma', () => {
+      expect(run(`[,]`)).toEqual([])
+      expect(run(`[,,]`)).toEqual([])
+      expect(run(`[246,]`)).toEqual([246])
+      expect(run(`[246,531,]`)).toEqual([246, 531])
+    })
     test('individual elements of an array can be accessed via the [<index>] notation', () => {
       expect(run(`let a = ['sun', 'mon', 'tue', 'wed']; a[1]`)).toEqual('mon')
     })
@@ -424,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)
@@ -455,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',
       )
@@ -515,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])
     })
@@ -606,6 +620,7 @@ describe('septima', () => {
     test(`captures the expression trace at runtime`, () => {
       expect(runSink(`1000 + 2000 + 3000 + sink!`).trace).toEqual(
         [
+          `  at (1:1..26) 1000 + 2000 + 3000 + sink!`,
           `  at (1:1..26) 1000 + 2000 + 3000 + sink!`,
           `  at (1:8..26) 2000 + 3000 + sink!`,
           `  at (1:15..26) 3000 + sink!`,
@@ -613,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`, () => {
@@ -623,9 +645,10 @@ 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)`,
           `  at (1:1..58) let a = 2; let f = fun(x, y) x * y * sink!! * a; f(30, 40)`,
           `  at (1:50..58) f(30, 40)`,
           `  at (1:30..47) x * y * sink!! * a`,
@@ -640,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', () => {
@@ -788,23 +816,51 @@ describe('septima', () => {
   })
   describe('preimport', () => {
     test('definitions from a preimported file can be used', () => {
-      const septima = new Septima(`libA.plus10(4) + libA.plus20(2)`, {
+      const septima = new Septima()
+
+      const input = `libA.plus10(4) + libA.plus20(2)`
+      const preimports = {
         libA: `{ plus10: fun (n) n+10, plus20: fun (n) n+20}`,
-      })
-      expect(septima.compute()).toMatchObject({ value: 36 })
+      }
+      expect(septima.compute(input, preimports, 'quiet', {})).toMatchObject({ value: 36 })
     })
     test('supports multiple preimports', () => {
-      const septima = new Septima(`a.calc(4) + b.calc(1)`, {
+      const septima = new Septima()
+
+      const input = `a.calc(4) + b.calc(1)`
+      const preimports = {
         a: `{ calc: fun (n) n+10 }`,
         b: `{ calc: fun (n) n+20 }`,
-      })
-      expect(septima.compute()).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')
@@ -819,4 +875,6 @@ describe('septima', () => {
   test.todo('number methods')
   test.todo('drop the fun () notation and use just arrow functions')
   test.todo('proper internal representation of arrow function, in particular: show(), span()')
+  test.todo('sink sinkifies arrays and objects it is stored at')
+  test.todo('{foo}')
 })