septima-lang 0.0.2 → 0.0.3

package/src/septima.ts

@@ -4,6 +4,7 @@ import { Runtime, Verbosity } from './runtime'
 import { Scanner } from './scanner'
 import { shouldNeverHappen } from './should-never-happen'
 import { SourceCode } from './source-code'
+import { Value } from './value'
 
 interface Options {
   /**
@@ -15,10 +16,6 @@ interface Options {
 }
 
 export class Septima {
-  private readonly scanner
-  private readonly sourceCode
-  private readonly parser
-
   /**
    * Runs a Septima program and returns the value it evaluates to. If it evaluates to `sink`, returns the value computed
    * by `options.onSink()` - if present, or throws an error - otherwise.
@@ -48,25 +45,42 @@ export class Septima {
     shouldNeverHappen(res)
   }
 
-  constructor(readonly input: string) {
-    this.sourceCode = new SourceCode(this.input)
-    this.scanner = new Scanner(this.sourceCode)
-    this.parser = new Parser(this.scanner)
-  }
+  constructor(readonly input: string, private readonly preimports: Record<string, string> = {}) {}
 
   compute(verbosity: Verbosity = 'quiet'): Result {
-    const ast = parse(this.parser)
-    const runtime = new Runtime(ast, verbosity, this.parser)
+    const lib: Record<string, Value> = {}
+    for (const [importName, importCode] of Object.entries(this.preimports)) {
+      const sourceCode = new SourceCode(importCode)
+      const value = this.computeImpl(sourceCode, verbosity, {})
+      if (value.isSink()) {
+        // TODO(imaman): cover!
+        const r = new ResultSinkImpl(value, sourceCode)
+        throw new Error(`preimport (${importName}) evaluated to sink: ${r.message}`)
+      }
+      lib[importName] = value
+    }
+
+    const sourceCode = new SourceCode(this.input)
+    const value = this.computeImpl(sourceCode, verbosity, lib)
+    if (!value.isSink()) {
+      return { value: value.export(), tag: 'ok' }
+    }
+    return new ResultSinkImpl(value, sourceCode)
+  }
+
+  private computeImpl(sourceCode: SourceCode, verbosity: Verbosity, lib: Record<string, Value>) {
+    const scanner = new Scanner(sourceCode)
+    const parser = new Parser(scanner)
+
+    const ast = parse(parser)
+    const runtime = new Runtime(ast, verbosity, lib)
     const c = runtime.compute()
 
     if (c.value) {
-      if (!c.value.isSink()) {
-        return { value: c.value.export(), tag: 'ok' }
-      }
-      return new ResultSinkImpl(c.value, this.sourceCode)
+      return c.value
     }
 
-    const runtimeErrorMessage = `${c.errorMessage} when evaluating:\n${this.sourceCode.formatTrace(c.expressionTrace)}`
+    const runtimeErrorMessage = `${c.errorMessage} when evaluating:\n${sourceCode.formatTrace(c.expressionTrace)}`
     throw new Error(runtimeErrorMessage)
   }
 }

package/tests/septima.spec.ts

@@ -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)
@@ -200,6 +204,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')
     })
@@ -282,6 +290,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 +424,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)
@@ -743,6 +786,28 @@ 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(`libA.plus10(4) + libA.plus20(2)`, {
+        libA: `{ plus10: fun (n) n+10, plus20: fun (n) n+20}`,
+      })
+      expect(septima.compute()).toMatchObject({ value: 36 })
+    })
+    test('supports multiple preimports', () => {
+      const septima = new Septima(`a.calc(4) + b.calc(1)`, {
+        a: `{ calc: fun (n) n+10 }`,
+        b: `{ calc: fun (n) n+20 }`,
+      })
+      expect(septima.compute()).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 +817,6 @@ 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()')
 })