septima-lang 0.0.2 → 0.0.5

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)
 
   if (res.tag !== 'sink') {
     throw new Error(`Not a sink: ${res.value}`)
@@ -30,6 +30,10 @@ describe('septima', () => {
     expect(() => run(`6 789`)).toThrowError(`Loitering input at (1:3..5) 789`)
     expect(run(`3.14`)).toEqual(3.14)
   })
+  test('an optional return keyword can be placed before the result', () => {
+    expect(run(`return 5`)).toEqual(5)
+    expect(run(`return 3.14`)).toEqual(3.14)
+  })
 
   test('booleans', () => {
     expect(run(`true`)).toEqual(true)
@@ -80,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')
@@ -200,6 +205,10 @@ describe('septima', () => {
       expect(run(`let x = 5; x+3`)).toEqual(8)
       expect(run(`let x = 5; let y = 20; x*y+4`)).toEqual(104)
     })
+    test('do not need the trailing semicolon', () => {
+      expect(run(`let x = 5 x+3`)).toEqual(8)
+      expect(run(`let x = 5 let y = 20 x*y+4`)).toEqual(104)
+    })
     test('fails if the variable was not defined', () => {
       expect(() => run(`let x = 5; x+y`)).toThrowError('Symbol y was not found')
     })
@@ -262,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')
     })
@@ -282,6 +297,14 @@ describe('septima', () => {
         expect(run(`{a: 1, b: 2}`)).toEqual({ a: 1, b: 2 })
         expect(run(`{a: "A", b: "B", c: "CCC"}`)).toEqual({ a: 'A', b: 'B', c: 'CCC' })
       })
+      test('allow a dangling comma', () => {
+        expect(run(`{a: 1,}`)).toEqual({ a: 1 })
+        expect(run(`{a: 1, b: 2,}`)).toEqual({ a: 1, b: 2 })
+        expect(run(`{a: "A", b: "B", c: "CCC",}`)).toEqual({ a: 'A', b: 'B', c: 'CCC' })
+      })
+      test('a dangling comma in an empty object is not allowed', () => {
+        expect(() => run(`{,}`)).toThrowError('Expected an identifier at (1:2..3) ,}')
+      })
       test('supports computed attributes names via the [<expression>]: <value> notation', () => {
         expect(run(`{["a" + 'b']: 'a-and-b'}`)).toEqual({ ab: 'a-and-b' })
       })
@@ -408,6 +431,33 @@ 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)
     })
+    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)
+      })
+      test('(a) => <expression>', () => {
+        expect(run(`let triple = (a) => 3*a; triple(100)`)).toEqual(300)
+      })
+      test('() => <expression>', () => {
+        expect(run(`let five = () => 5; five()`)).toEqual(5)
+      })
+      test('(a,b) => <expression>', () => {
+        expect(run(`let conc = (a,b) => a+b; conc('al', 'pha')`)).toEqual('alpha')
+        expect(run(`let conc = (a,b,c,d,e,f) => a+b+c+d+e+f; conc('M', 'o', 'n', 'd', 'a', 'y')`)).toEqual('Monday')
+      })
+      test('body of an arrow function can be { return <expression>}', () => {
+        expect(run(`let triple = a => { return 3*a }; triple(100)`)).toEqual(300)
+        expect(run(`let triple = (a) => { return 3*a }; triple(100)`)).toEqual(300)
+        expect(run(`let five = () => { return 5 }; five()`)).toEqual(5)
+        expect(run(`let concat = (a,b) => { return a+b }; concat('al', 'pha')`)).toEqual('alpha')
+      })
+      test('body of an arrow function can include let definitions', () => {
+        expect(run(`let triple = a => { let factor = 3; return factor*a }; triple(100)`)).toEqual(300)
+        expect(run(`let triple = (a) => { let factor = 3; return 3*a }; triple(100)`)).toEqual(300)
+        expect(run(`let five = () => { let two = 2; let three = 3; return three+two }; five()`)).toEqual(5)
+        expect(run(`let concat = (a,b) => { let u = '_'; return u+a+b+u }; concat('a', 'b')`)).toEqual('_ab_')
+      })
+    })
     test('can have no args', () => {
       expect(run(`let pi = fun() 3.14; 2*pi()`)).toEqual(6.28)
       expect(run(`(fun() 3.14)()*2`)).toEqual(6.28)
@@ -563,6 +613,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!`,
@@ -583,6 +634,7 @@ describe('septima', () => {
       expect(Object.keys(actual.symbols ?? {})).toEqual(['Object', '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`,
@@ -743,6 +795,34 @@ describe('septima', () => {
       expect(run(`let count = fun (n) if (n <= 0) 0 else 1 + count(n-1); count(330)`)).toEqual(330)
     })
   })
+  describe('preimport', () => {
+    test('definitions from a preimported file can be used', () => {
+      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(input, preimports)).toMatchObject({ value: 36 })
+    })
+    test('supports multiple preimports', () => {
+      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(input, preimports)).toMatchObject({ value: 35 })
+    })
+  })
+  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')
   test.todo('left associativity of +/-')
   test.todo('comparison of arrays')
   test.todo('comparison of lambdas?')
@@ -752,4 +832,8 @@ describe('septima', () => {
   test.todo('quoting of a ticks inside a string')
   test.todo('number in scientific notation')
   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}')
 })