septima-lang 0.0.1 → 0.0.4

package/src/parser.ts

@@ -22,14 +22,18 @@ export class Parser {
       const ident = this.identifier()
       this.scanner.consume('=')
       const value = this.lambda()
-      this.scanner.consume(';')
-
       ret.push({ start, ident, value })
+
+      this.scanner.consumeIf(';')
+      if (!this.scanner.headMatches('let ')) {
+        return ret
+      }
     }
   }
 
   expression(): AstNode {
     const definitions = this.definitions()
+    this.scanner.consumeIf('return')
     const computation = this.lambda()
 
     if (definitions.length === 0) {
@@ -42,7 +46,7 @@ export class Parser {
   lambda(): AstNode {
     const start = this.scanner.consumeIf('fun')
     if (!start) {
-      return this.ifExpression()
+      return this.arrowFunction()
     }
 
     this.scanner.consume('(')
@@ -66,6 +70,60 @@ export class Parser {
     return { tag: 'lambda', start, formalArgs: args, body }
   }
 
+  arrowFunction(): AstNode {
+    if (this.scanner.headMatches('(', ')', '=>')) {
+      const start = this.scanner.consume('(')
+      this.scanner.consume(')')
+      this.scanner.consume('=>')
+      const body = this.lambdaBody()
+      return { tag: 'lambda', start, formalArgs: [], body }
+    }
+    if (this.scanner.headMatches(IDENT_PATTERN, '=>')) {
+      const ident = this.identifier()
+      this.scanner.consume('=>')
+      const body = this.lambdaBody()
+      return { tag: 'lambda', start: ident.t, formalArgs: [ident], body }
+    }
+    if (this.scanner.headMatches('(', IDENT_PATTERN, ')', '=>')) {
+      const start = this.scanner.consume('(')
+      const ident = this.identifier()
+      this.scanner.consume(')')
+      this.scanner.consume('=>')
+      const body = this.lambdaBody()
+      return { tag: 'lambda', start, formalArgs: [ident], body }
+    }
+    if (this.scanner.headMatches('(', IDENT_PATTERN, ',')) {
+      const start = this.scanner.consume('(')
+      const formalArgs: Ident[] = []
+      while (true) {
+        const ident = this.identifier()
+        formalArgs.push(ident)
+
+        if (this.scanner.consumeIf(')')) {
+          break
+        }
+
+        this.scanner.consume(',')
+      }
+
+      this.scanner.consume('=>')
+      const body = this.lambdaBody()
+      return { tag: 'lambda', start, formalArgs, body }
+    }
+
+    return this.ifExpression()
+  }
+
+  private lambdaBody() {
+    if (this.scanner.consumeIf('{')) {
+      const ret = this.expression()
+      this.scanner.consume('}')
+      return ret
+    }
+
+    return this.expression()
+  }
+
   ifExpression(): AstNode {
     if (!this.scanner.consumeIf('if')) {
       return this.unsink()
@@ -326,6 +384,13 @@ export class Parser {
 
     const parts: ArrayLiteralPart[] = []
     while (true) {
+      if (this.scanner.consumeIf(',')) {
+        const end = this.scanner.consumeIf(']')
+        if (end) {
+          return { tag: 'arrayLiteral', start, parts, end }
+        }
+        continue
+      }
       if (this.scanner.consumeIf('...')) {
         parts.push({ tag: 'spread', v: this.expression() })
       } else {
@@ -333,12 +398,16 @@ export class Parser {
         parts.push({ tag: 'element', v: exp })
       }
 
-      const end = this.scanner.consumeIf(']')
+      let end = this.scanner.consumeIf(']')
       if (end) {
         return { tag: 'arrayLiteral', start, parts, end }
       }
 
       this.scanner.consume(',')
+      end = this.scanner.consumeIf(']')
+      if (end) {
+        return { tag: 'arrayLiteral', start, parts, end }
+      }
     }
   }
 
@@ -370,12 +439,16 @@ export class Parser {
         parts.push({ tag: 'hardName', k, v })
       }
 
-      const end = this.scanner.consumeIf('}')
+      let end = this.scanner.consumeIf('}')
       if (end) {
         return { tag: 'objectLiteral', start, parts, end }
       }
 
       this.scanner.consume(',')
+      end = this.scanner.consumeIf('}')
+      if (end) {
+        return { tag: 'objectLiteral', start, parts, end }
+      }
     }
   }
 
@@ -389,7 +462,7 @@ export class Parser {
   }
 
   private maybeIdentifier(): Ident | undefined {
-    const t = this.scanner.consumeIf(/[a-zA-Z][0-9A-Za-z_]*/)
+    const t = this.scanner.consumeIf(IDENT_PATTERN)
     if (t) {
       return { tag: 'ident', t }
     }
@@ -397,3 +470,5 @@ export class Parser {
     return undefined
   }
 }
+
+const IDENT_PATTERN = /[a-zA-Z][0-9A-Za-z_]*/

package/src/runtime.ts

@@ -1,7 +1,6 @@
 import { AstNode, show, span } from './ast-node'
 import { extractMessage } from './extract-message'
 import { failMe } from './fail-me'
-import { Parser } from './parser'
 import { shouldNeverHappen } from './should-never-happen'
 import * as Stack from './stack'
 import { switchOn } from './switch-on'
@@ -51,7 +50,7 @@ export class Runtime {
   constructor(
     private readonly root: AstNode,
     private readonly verbosity: Verbosity = 'quiet',
-    private readonly parser: Parser,
+    private readonly preimports: Record<string, Value> = {},
   ) {}
 
   compute() {
@@ -60,7 +59,12 @@ export class Runtime {
     const keys = Value.foreign(o => o.keys())
     const entries = Value.foreign(o => o.entries())
     const fromEntries = Value.foreign(o => o.fromEntries())
-    const lib = new SymbolFrame('Object', { destination: Value.obj({ keys, entries, fromEntries }) }, empty)
+    let lib = new SymbolFrame('Object', { destination: Value.obj({ keys, entries, fromEntries }) }, empty)
+
+    for (const [importName, importValue] of Object.entries(this.preimports)) {
+      lib = new SymbolFrame(importName, { destination: importValue }, lib)
+    }
+
     try {
       const value = this.evalNode(this.root, lib)
       return { value }

package/src/scanner.ts

@@ -7,10 +7,10 @@ export interface Token {
 }
 
 export class Scanner {
-  private offset = 0
-
-  constructor(private readonly sourceCode: SourceCode) {
-    this.eatWhitespace()
+  constructor(private readonly sourceCode: SourceCode, private offset = 0) {
+    if (this.offset === 0) {
+      this.eatWhitespace()
+    }
   }
 
   get sourceRef() {
@@ -52,6 +52,18 @@ export class Scanner {
     }
   }
 
+  headMatches(...patterns: (RegExp | string)[]): boolean {
+    const alt = new Scanner(this.sourceCode, this.offset)
+    for (const p of patterns) {
+      const t = alt.consumeIf(p, true)
+      if (t === undefined) {
+        return false
+      }
+    }
+
+    return true
+  }
+
   consume(r: RegExp | string, eatWhitespace = true): Token {
     const text = this.match(r)
     if (text === undefined) {

package/src/septima.ts

@@ -0,0 +1,92 @@
+import { Parser } from './parser'
+import { Result, ResultSink, ResultSinkImpl } from './result'
+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 {
+  /**
+   * A callback function to be invoked when the Septima program evaluated to `sink`. Allows the caller to determine
+   * which value will be returned in that case. For instance, passing `() => undefined` will translate a `sink` value
+   * to `undefined`. The default behavior is to throw an error.
+   */
+  onSink?: (res: ResultSink) => unknown
+}
+
+export class Septima {
+  /**
+   * 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.
+   *
+   * This method is the simplest way to evaluate a Septima program, and it fits many common use cases. One can also use
+   * `.compute()` to get additional details about the execution.
+   *
+   * @param input the source code of the Septima program
+   * @param options
+   * @returns the value that `input` evaluates to
+   */
+  static run(input: string, options?: Options): unknown {
+    const onSink =
+      options?.onSink ??
+      ((r: ResultSink) => {
+        throw new Error(r.message)
+      })
+    const res = new Septima(input).compute()
+    if (res.tag === 'ok') {
+      return res.value
+    }
+
+    if (res.tag === 'sink') {
+      return onSink(res)
+    }
+
+    shouldNeverHappen(res)
+  }
+
+  constructor(readonly input: string, private readonly preimports: Record<string, string> = {}) {}
+
+  compute(verbosity: Verbosity = 'quiet'): Result {
+    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) {
+      return c.value
+    }
+
+    const runtimeErrorMessage = `${c.errorMessage} when evaluating:\n${sourceCode.formatTrace(c.expressionTrace)}`
+    throw new Error(runtimeErrorMessage)
+  }
+}
+
+export function parse(arg: string | Parser) {
+  const parser = typeof arg === 'string' ? new Parser(new Scanner(new SourceCode(arg))) : arg
+  const ast = parser.parse()
+  return ast
+}

package/tests/parser.spec.ts

@@ -1,14 +1,14 @@
 import { show } from '../src/ast-node'
-import * as cdl from '../src/cdl'
+import { parse } from '../src/septima'
 
 describe('parser', () => {
   test('show()', () => {
-    expect(show(cdl.parse(`5`))).toEqual('5')
-    expect(show(cdl.parse(`fun (x) x*9`))).toEqual('fun (x) (x * 9)')
+    expect(show(parse(`5`))).toEqual('5')
+    expect(show(parse(`fun (x) x*9`))).toEqual('fun (x) (x * 9)')
   })
   test('syntax errors', () => {
-    expect(() => cdl.parse(`a + #$%x`)).toThrowError('Unparsable input at (1:5..8) #$%x')
-    expect(() => cdl.parse(`{#$%x: 8}`)).toThrowError('Expected an identifier at (1:2..9) #$%x: 8}')
-    expect(() => cdl.parse(`"foo" "goo"`)).toThrowError('Loitering input at (1:7..11) "goo"')
+    expect(() => parse(`a + #$%x`)).toThrowError('Unparsable input at (1:5..8) #$%x')
+    expect(() => parse(`{#$%x: 8}`)).toThrowError('Expected an identifier at (1:2..9) #$%x: 8}')
+    expect(() => parse(`"foo" "goo"`)).toThrowError('Loitering input at (1:7..11) "goo"')
   })
 })

package/tests/{cdl.spec.ts → septima.spec.ts}

@@ -1,22 +1,22 @@
-import { Cdl } from '../src/cdl'
+import { Septima } from '../src/septima'
 
 /**
- * Runs a CDL program for testing purposes. If the CDL program evaluated to `sink` an `undefined` is
+ * Runs a Septima program for testing purposes. If the program evaluates to `sink` an `undefined` is
  * returned.
- * @param input the CDL program to run
+ * @param input the Septima program to run
  */
 function run(input: string) {
-  return Cdl.run(input, { onSink: () => undefined })
+  return Septima.run(input, { onSink: () => undefined })
 }
 
 /**
- * Runs a CDL program for testing purposes. The program is expected to evaluate to `sink`. Throws an exception if that
- * is not the case.
- * @param input the CDL program to run
+ * Runs a Septima program for testing purposes. The program is expected to evaluate to `sink`. Throws an exception if
+ * this expectation is not met.
+ * @param input the Septima program to run
  */
 function runSink(input: string) {
-  const cdl = new Cdl(input)
-  const res = cdl.compute()
+  const septima = new Septima(input)
+  const res = septima.compute()
 
   if (res.tag !== 'sink') {
     throw new Error(`Not a sink: ${res.value}`)
@@ -24,12 +24,16 @@ function runSink(input: string) {
   return res
 }
 
-describe('cdl', () => {
+describe('septima', () => {
   test('basics', () => {
     expect(run(`5`)).toEqual(5)
     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('cdl', () => {
       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 +270,12 @@ describe('cdl', () => {
       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 +296,14 @@ describe('cdl', () => {
         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 +430,33 @@ describe('cdl', () => {
       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 +792,28 @@ describe('cdl', () => {
       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 +823,6 @@ describe('cdl', () => {
   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()')
 })

package/dist/src/cdl.d.ts

@@ -1,33 +0,0 @@
-import { Parser } from './parser';
-import { Result, ResultSink } from './result';
-import { Verbosity } from './runtime';
-interface Options {
-    /**
-     * A callback function to be invoked when the CDL program evaluated to `sink`. Allows the caller to determine which
-     * value will be returned in that case. For instance, passing `() => undefined` will translate a `sink` value to
-     * `undefined`. The default behavior is to throw an error.
-     */
-    onSink?: (res: ResultSink) => unknown;
-}
-export declare class Cdl {
-    readonly input: string;
-    private readonly scanner;
-    private readonly sourceCode;
-    private readonly parser;
-    /**
-     * Runs a CDL 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.
-     *
-     * This method is the simplest way to evaluate a CDL program. One can also use `.compute()` to get a higher degree
-     * of details about the result.
-     *
-     * @param input the source code of the CDL program
-     * @param options
-     * @returns the value that `input` evaluates to
-     */
-    static run(input: string, options?: Options): unknown;
-    constructor(input: string);
-    compute(verbosity?: Verbosity): Result;
-}
-export declare function parse(arg: string | Parser): import("./ast-node").AstNode;
-export {};

package/dist/src/cdl.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = exports.Cdl = void 0;
-const parser_1 = require("./parser");
-const result_1 = require("./result");
-const runtime_1 = require("./runtime");
-const scanner_1 = require("./scanner");
-const should_never_happen_1 = require("./should-never-happen");
-const source_code_1 = require("./source-code");
-class Cdl {
-    constructor(input) {
-        this.input = input;
-        this.sourceCode = new source_code_1.SourceCode(this.input);
-        this.scanner = new scanner_1.Scanner(this.sourceCode);
-        this.parser = new parser_1.Parser(this.scanner);
-    }
-    /**
-     * Runs a CDL 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.
-     *
-     * This method is the simplest way to evaluate a CDL program. One can also use `.compute()` to get a higher degree
-     * of details about the result.
-     *
-     * @param input the source code of the CDL program
-     * @param options
-     * @returns the value that `input` evaluates to
-     */
-    static run(input, options) {
-        const onSink = options?.onSink ??
-            ((r) => {
-                throw new Error(r.message);
-            });
-        const res = new Cdl(input).compute();
-        if (res.tag === 'ok') {
-            return res.value;
-        }
-        if (res.tag === 'sink') {
-            return onSink(res);
-        }
-        (0, should_never_happen_1.shouldNeverHappen)(res);
-    }
-    compute(verbosity = 'quiet') {
-        const ast = parse(this.parser);
-        const runtime = new runtime_1.Runtime(ast, verbosity, this.parser);
-        const c = runtime.compute();
-        if (c.value) {
-            if (!c.value.isSink()) {
-                return { value: c.value.export(), tag: 'ok' };
-            }
-            return new result_1.ResultSinkImpl(c.value, this.sourceCode);
-        }
-        const runtimeErrorMessage = `${c.errorMessage} when evaluating:\n${this.sourceCode.formatTrace(c.expressionTrace)}`;
-        throw new Error(runtimeErrorMessage);
-    }
-}
-exports.Cdl = Cdl;
-function parse(arg) {
-    const parser = typeof arg === 'string' ? new parser_1.Parser(new scanner_1.Scanner(new source_code_1.SourceCode(arg))) : arg;
-    const ast = parser.parse();
-    return ast;
-}
-exports.parse = parse;
-//# sourceMappingURL=data:application/json;base64,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