septima-lang 0.0.3 → 0.0.6

package/src/ast-node.ts

@@ -1,9 +1,22 @@
 import { Span } from './location'
 import { Token } from './scanner'
 import { shouldNeverHappen } from './should-never-happen'
+import { switchOn } from './switch-on'
 
 export type Let = { start: Token; ident: Ident; value: AstNode }
 
+export type Import = {
+  start: Token
+  ident: Ident
+  pathToImportFrom: Token
+}
+
+export type Literal = {
+  tag: 'literal'
+  type: 'str' | 'bool' | 'num' | 'sink' | 'sink!' | 'sink!!'
+  t: Token
+}
+
 export type ObjectLiteralPart =
   | { tag: 'hardName'; k: Ident; v: AstNode }
   | { tag: 'computedName'; k: AstNode; v: AstNode }
@@ -23,8 +36,16 @@ export type Lambda = {
   body: AstNode
 }
 
+export type Unit = {
+  tag: 'unit'
+  imports: Import[]
+  expression: AstNode
+}
+
 export type AstNode =
   | Ident
+  | Literal
+  | Unit
   | {
       start: Token
       tag: 'arrayLiteral'
@@ -37,11 +58,6 @@ export type AstNode =
       parts: ObjectLiteralPart[]
       end: Token
     }
-  | {
-      tag: 'literal'
-      type: 'str' | 'bool' | 'num' | 'sink' | 'sink!' | 'sink!!'
-      t: Token
-    }
   | {
       tag: 'binaryOperator'
       operator: '+' | '-' | '*' | '/' | '**' | '%' | '&&' | '||' | '>' | '<' | '>=' | '<=' | '==' | '!=' | '??'
@@ -82,6 +98,12 @@ export type AstNode =
       receiver: AstNode
       index: AstNode
     }
+  | {
+      // A sepcial AST node meant to be generated internally (needed for exporting definition from one unit to another).
+      // Not intended to be parsed from source code. Hence, it is effectively empty, and its location cannot be
+      // determined.
+      tag: 'export*'
+    }
 
 export function show(ast: AstNode | AstNode[]): string {
   if (Array.isArray(ast)) {
@@ -105,11 +127,12 @@ export function show(ast: AstNode | AstNode[]): string {
   if (ast.tag === 'binaryOperator') {
     return `(${show(ast.lhs)} ${ast.operator} ${show(ast.rhs)})`
   }
-
   if (ast.tag === 'dot') {
     return `${show(ast.receiver)}.${show(ast.ident)}`
   }
-
+  if (ast.tag === 'export*') {
+    return `(export*)`
+  }
   if (ast.tag === 'functionCall') {
     return `${show(ast.callee)}(${show(ast.actualArgs)})`
   }
@@ -126,7 +149,14 @@ export function show(ast: AstNode | AstNode[]): string {
     return `fun (${show(ast.formalArgs)}) ${show(ast.body)}`
   }
   if (ast.tag === 'literal') {
-    return ast.t.text
+    return switchOn(ast.type, {
+      bool: () => ast.t.text,
+      num: () => ast.t.text,
+      sink: () => 'sink',
+      'sink!': () => 'sink!',
+      'sink!!': () => 'sink!!',
+      str: () => `'${ast.t.text}'`,
+    })
   }
   if (ast.tag === 'objectLiteral') {
     const pairs = ast.parts.map(p => {
@@ -153,6 +183,12 @@ export function show(ast: AstNode | AstNode[]): string {
   if (ast.tag === 'unaryOperator') {
     return `${ast.operator}${show(ast.operand)}`
   }
+  if (ast.tag === 'unit') {
+    const imports = ast.imports
+      .map(imp => `import * as ${show(imp.ident)} from '${imp.pathToImportFrom.text}';`)
+      .join('\n')
+    return `${imports ? imports + '\n' : ''}${show(ast.expression)}`
+  }
 
   shouldNeverHappen(ast)
 }
@@ -176,6 +212,9 @@ export function span(ast: AstNode): Span {
   if (ast.tag === 'ident') {
     return ofToken(ast.t)
   }
+  if (ast.tag === 'export*') {
+    return { from: { offset: 0 }, to: { offset: 0 } }
+  }
   if (ast.tag === 'if') {
     return ofRange(span(ast.condition), span(ast.negative))
   }
@@ -200,6 +239,11 @@ export function span(ast: AstNode): Span {
   if (ast.tag === 'unaryOperator') {
     return ofRange(ofToken(ast.operatorToken), span(ast.operand))
   }
+  if (ast.tag === 'unit') {
+    const i0 = ast.imports.find(Boolean)
+    const exp = span(ast.expression)
+    return ofRange(i0 ? ofToken(i0.start) : exp, exp)
+  }
 
   shouldNeverHappen(ast)
 }

package/src/parser.ts

@@ -1,17 +1,58 @@
-import { ArrayLiteralPart, AstNode, Ident, Let, ObjectLiteralPart } from './ast-node'
+import { ArrayLiteralPart, AstNode, Ident, Import, Let, Literal, ObjectLiteralPart, span, Unit } from './ast-node'
 import { Scanner, Token } from './scanner'
+import { switchOn } from './switch-on'
 
 export class Parser {
   constructor(private readonly scanner: Scanner) {}
 
-  parse() {
-    const ret = this.expression()
+  parse(): Unit {
+    const ret = this.unit()
     if (!this.scanner.eof()) {
       throw new Error(`Loitering input ${this.scanner.sourceRef}`)
     }
     return ret
   }
 
+  unit(): Unit {
+    const imports = this.imports()
+    const expression = this.expression()
+    return { tag: 'unit', imports, expression }
+  }
+
+  imports(): Import[] {
+    const ret: Import[] = []
+    while (true) {
+      const start = this.scanner.consumeIf('import')
+      if (!start) {
+        return ret
+      }
+
+      this.scanner.consume('*')
+      this.scanner.consume('as')
+      const ident = this.identifier()
+      this.scanner.consume('from')
+      const pathToImportFrom = this.maybePrimitiveLiteral()
+      if (pathToImportFrom === undefined) {
+        throw new Error(`Expected a literal ${this.scanner.sourceRef}`)
+      }
+
+      const notString = () => {
+        throw new Error(`Expected a string literal ${this.scanner.sourceCode.sourceRef(span(pathToImportFrom))}`)
+      }
+      switchOn(pathToImportFrom.type, {
+        bool: notString,
+        num: notString,
+        str: () => {},
+        sink: notString,
+        'sink!': notString,
+        'sink!!': notString,
+      })
+      ret.push({ start, ident, pathToImportFrom: pathToImportFrom.t })
+
+      this.scanner.consumeIf(';')
+    }
+  }
+
   definitions(): Let[] {
     const ret: Let[] = []
     while (true) {
@@ -266,11 +307,15 @@ export class Parser {
     while (true) {
       const arg = this.expression()
       actualArgs.push(arg)
-      const end = this.scanner.consumeIf(')')
+      let end = this.scanner.consumeIf(')')
       if (end) {
         return { actualArgs, end }
       }
       this.scanner.consume(',')
+      end = this.scanner.consumeIf(')')
+      if (end) {
+        return { actualArgs, end }
+      }
     }
   }
 
@@ -310,17 +355,29 @@ export class Parser {
   }
 
   literalOrIdent(): AstNode {
-    let t = this.scanner.consumeIf('sink!!')
+    const ret = this.maybeLiteral() ?? this.maybeIdentifier()
+    if (!ret) {
+      throw new Error(`Unparsable input ${this.scanner.sourceRef}`)
+    }
+    return ret
+  }
+
+  maybeLiteral(): AstNode | undefined {
+    return this.maybePrimitiveLiteral() ?? this.maybeCompositeLiteral()
+  }
+
+  maybePrimitiveLiteral(): Literal | undefined {
+    let t = this.scanner.consumeIf('sink!!') || this.scanner.consumeIf('undefined!!')
     if (t) {
       return { tag: 'literal', type: 'sink!!', t }
     }
 
-    t = this.scanner.consumeIf('sink!')
+    t = this.scanner.consumeIf('sink!') || this.scanner.consumeIf('undefined!')
     if (t) {
       return { tag: 'literal', type: 'sink!', t }
     }
 
-    t = this.scanner.consumeIf('sink')
+    t = this.scanner.consumeIf('sink') || this.scanner.consumeIf('undefined')
     if (t) {
       return { tag: 'literal', type: 'sink', t }
     }
@@ -353,7 +410,11 @@ export class Parser {
       return { tag: 'literal', type: 'str', t }
     }
 
-    t = this.scanner.consumeIf('[')
+    return undefined
+  }
+
+  maybeCompositeLiteral(): AstNode | undefined {
+    let t = this.scanner.consumeIf('[')
     if (t) {
       return this.arrayBody(t)
     }
@@ -363,12 +424,7 @@ export class Parser {
       return this.objectBody(t)
     }
 
-    const ident = this.maybeIdentifier()
-    if (ident) {
-      return ident
-    }
-
-    throw new Error(`Unparsable input ${this.scanner.sourceRef}`)
+    return undefined
   }
 
   /**
@@ -384,6 +440,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 {
@@ -391,12 +454,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 }
+      }
     }
   }
 

package/src/runtime.ts

@@ -1,4 +1,4 @@
-import { AstNode, show, span } from './ast-node'
+import { AstNode, show, span, Unit } from './ast-node'
 import { extractMessage } from './extract-message'
 import { failMe } from './fail-me'
 import { shouldNeverHappen } from './should-never-happen'
@@ -31,6 +31,12 @@ class SymbolFrame implements SymbolTable {
     ret[this.symbol] = this.placeholder.destination?.export() ?? failMe(`Unbounded symbol: ${this.symbol}`)
     return ret
   }
+
+  exportValue(): Record<string, Value> {
+    const ret = this.earlier.exportValue()
+    ret[this.symbol] = this.placeholder.destination ?? failMe(`Unbounded symbol: ${this.symbol}`)
+    return ret
+  }
 }
 
 class EmptySymbolTable implements SymbolTable {
@@ -41,6 +47,10 @@ class EmptySymbolTable implements SymbolTable {
   export() {
     return {}
   }
+
+  exportValue(): Record<string, Value> {
+    return {}
+  }
 }
 
 export type Verbosity = 'quiet' | 'trace'
@@ -50,10 +60,12 @@ export class Runtime {
   constructor(
     private readonly root: AstNode,
     private readonly verbosity: Verbosity = 'quiet',
-    private readonly preimports: Record<string, Value> = {},
+    private readonly preimports: Record<string, Value>,
+    private readonly getAstOf: (fileName: string) => Unit,
+    private readonly args: Record<string, unknown>,
   ) {}
 
-  compute() {
+  private buildInitialSymbolTable(generateTheArgsObject: boolean) {
     const empty = new EmptySymbolTable()
 
     const keys = Value.foreign(o => o.keys())
@@ -61,12 +73,19 @@ export class Runtime {
     const fromEntries = Value.foreign(o => o.fromEntries())
     let lib = new SymbolFrame('Object', { destination: Value.obj({ keys, entries, fromEntries }) }, empty)
 
+    if (generateTheArgsObject) {
+      lib = new SymbolFrame('args', { destination: Value.from(this.args) }, lib)
+    }
+
     for (const [importName, importValue] of Object.entries(this.preimports)) {
       lib = new SymbolFrame(importName, { destination: importValue }, lib)
     }
+    return lib
+  }
 
+  compute() {
     try {
-      const value = this.evalNode(this.root, lib)
+      const value = this.evalNode(this.root, this.buildInitialSymbolTable(true))
       return { value }
     } catch (e) {
       const trace: AstNode[] = []
@@ -99,7 +118,50 @@ export class Runtime {
     return ret
   }
 
+  private importDefinitions(pathToImportFrom: string): Value {
+    const ast = this.getAstOf(pathToImportFrom)
+    const exp = ast.expression
+    const imports = ast.imports
+    if (
+      exp.tag === 'arrayLiteral' ||
+      exp.tag === 'binaryOperator' ||
+      exp.tag === 'dot' ||
+      exp.tag === 'export*' ||
+      exp.tag === 'functionCall' ||
+      exp.tag === 'ident' ||
+      exp.tag === 'if' ||
+      exp.tag === 'indexAccess' ||
+      exp.tag === 'lambda' ||
+      exp.tag === 'literal' ||
+      exp.tag === 'objectLiteral' ||
+      exp.tag === 'unaryOperator' ||
+      exp.tag === 'unit'
+    ) {
+      // TODO(imaman): throw an error on non-exporting unit?
+      return Value.obj({})
+    }
+
+    if (exp.tag === 'topLevelExpression') {
+      const unit: AstNode = {
+        tag: 'unit',
+        imports,
+        expression: { tag: 'topLevelExpression', definitions: exp.definitions, computation: { tag: 'export*' } },
+      }
+      return this.evalNode(unit, this.buildInitialSymbolTable(false))
+    }
+
+    shouldNeverHappen(exp)
+  }
+
   private evalNodeImpl(ast: AstNode, table: SymbolTable): Value {
+    if (ast.tag === 'unit') {
+      let newTable = table
+      for (const imp of ast.imports) {
+        const o = this.importDefinitions(imp.pathToImportFrom.text)
+        newTable = new SymbolFrame(imp.ident.t.text, { destination: o }, newTable)
+      }
+      return this.evalNode(ast.expression, newTable)
+    }
     if (ast.tag === 'topLevelExpression') {
       let newTable = table
       for (const def of ast.definitions) {
@@ -113,6 +175,10 @@ export class Runtime {
       return this.evalNode(ast.computation, newTable)
     }
 
+    if (ast.tag === 'export*') {
+      return Value.obj(table.exportValue())
+    }
+
     if (ast.tag === 'binaryOperator') {
       const lhs = this.evalNode(ast.lhs, table)
       if (ast.operator === '||') {

package/src/scanner.ts

@@ -7,7 +7,7 @@ export interface Token {
 }
 
 export class Scanner {
-  constructor(private readonly sourceCode: SourceCode, private offset = 0) {
+  constructor(readonly sourceCode: SourceCode, private offset = 0) {
     if (this.offset === 0) {
       this.eatWhitespace()
     }

package/src/septima.ts

@@ -1,3 +1,4 @@
+import { Unit } from './ast-node'
 import { Parser } from './parser'
 import { Result, ResultSink, ResultSinkImpl } from './result'
 import { Runtime, Verbosity } from './runtime'
@@ -27,13 +28,13 @@ export class Septima {
    * @param options
    * @returns the value that `input` evaluates to
    */
-  static run(input: string, options?: Options): unknown {
+  static run(input: string, options?: Options, args: Record<string, unknown> = {}): unknown {
     const onSink =
       options?.onSink ??
       ((r: ResultSink) => {
         throw new Error(r.message)
       })
-    const res = new Septima(input).compute()
+    const res = new Septima().compute(input, {}, 'quiet', args)
     if (res.tag === 'ok') {
       return res.value
     }
@@ -45,13 +46,28 @@ export class Septima {
     shouldNeverHappen(res)
   }
 
-  constructor(readonly input: string, private readonly preimports: Record<string, string> = {}) {}
+  constructor() {}
 
-  compute(verbosity: Verbosity = 'quiet'): Result {
+  computeModule(moduleName: string, moduleReader: (m: string) => string, args: Record<string, unknown>): Result {
+    const input = moduleReader(moduleName)
+    const sourceCode = new SourceCode(input)
+    const value = this.computeImpl(sourceCode, 'quiet', {}, moduleReader, args)
+    if (!value.isSink()) {
+      return { value: value.export(), tag: 'ok' }
+    }
+    return new ResultSinkImpl(value, sourceCode)
+  }
+
+  compute(
+    input: string,
+    preimports: Record<string, string> = {},
+    verbosity: Verbosity = 'quiet',
+    args: Record<string, unknown>,
+  ): Result {
     const lib: Record<string, Value> = {}
-    for (const [importName, importCode] of Object.entries(this.preimports)) {
+    for (const [importName, importCode] of Object.entries(preimports)) {
       const sourceCode = new SourceCode(importCode)
-      const value = this.computeImpl(sourceCode, verbosity, {})
+      const value = this.computeImpl(sourceCode, verbosity, {}, undefined, {})
       if (value.isSink()) {
         // TODO(imaman): cover!
         const r = new ResultSinkImpl(value, sourceCode)
@@ -60,20 +76,33 @@ export class Septima {
       lib[importName] = value
     }
 
-    const sourceCode = new SourceCode(this.input)
-    const value = this.computeImpl(sourceCode, verbosity, lib)
+    const sourceCode = new SourceCode(input)
+    const value = this.computeImpl(sourceCode, verbosity, lib, undefined, args)
     if (!value.isSink()) {
       return { value: value.export(), tag: 'ok' }
     }
     return new ResultSinkImpl(value, sourceCode)
   }
 
-  private computeImpl(sourceCode: SourceCode, verbosity: Verbosity, lib: Record<string, Value>) {
+  private computeImpl(
+    sourceCode: SourceCode,
+    verbosity: Verbosity,
+    lib: Record<string, Value>,
+    moduleReader: undefined | ((m: string) => string),
+    args: Record<string, unknown>,
+  ) {
     const scanner = new Scanner(sourceCode)
     const parser = new Parser(scanner)
-
     const ast = parse(parser)
-    const runtime = new Runtime(ast, verbosity, lib)
+
+    const getAstOf = (fileName: string) => {
+      if (!moduleReader) {
+        throw new Error(`cannot read modules`)
+      }
+      return parse(moduleReader(fileName))
+    }
+
+    const runtime = new Runtime(ast, verbosity, lib, getAstOf, args)
     const c = runtime.compute()
 
     if (c.value) {
@@ -85,7 +114,7 @@ export class Septima {
   }
 }
 
-export function parse(arg: string | Parser) {
+export function parse(arg: string | Parser): Unit {
   const parser = typeof arg === 'string' ? new Parser(new Scanner(new SourceCode(arg))) : arg
   const ast = parser.parse()
   return ast

package/src/symbol-table.ts

@@ -3,4 +3,5 @@ import { Value } from './value'
 export interface SymbolTable {
   lookup(sym: string): Value
   export(): Record<string, unknown>
+  exportValue(): Record<string, Value>
 }

package/tests/parser.spec.ts

@@ -11,4 +11,20 @@ describe('parser', () => {
     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"')
   })
+
+  describe('unit', () => {
+    test('show', () => {
+      expect(show(parse(`import * as foo from './bar';'a'`))).toEqual(`import * as foo from './bar';\n'a'`)
+    })
+  })
+  describe('expression', () => {
+    test('show', () => {
+      expect(show(parse(`'sunday'`))).toEqual(`'sunday'`)
+      expect(show(parse(`true`))).toEqual(`true`)
+      expect(show(parse(`500`))).toEqual(`500`)
+      expect(show(parse(`sink`))).toEqual(`sink`)
+      expect(show(parse(`sink!`))).toEqual(`sink!`)
+      expect(show(parse(`sink!!`))).toEqual(`sink!!`)
+    })
+  })
 })

package/tests/septima-compute-module.spec.ts

@@ -0,0 +1,41 @@
+import { Septima } from '../src/septima'
+import { shouldNeverHappen } from '../src/should-never-happen'
+
+/**
+ * Runs a Septima program for testing purposes. Throws an error If the program evaluated to `sink`.
+ */
+async function run(mainModule: string, inputs: Record<string, string>, args: Record<string, unknown> = {}) {
+  const septima = new Septima()
+  const res = septima.computeModule(mainModule, (m: string) => inputs[m], args)
+  if (res.tag === 'ok') {
+    return res.value
+  }
+
+  if (res.tag === 'sink') {
+    throw new Error(res.message)
+  }
+
+  shouldNeverHappen(res)
+}
+
+describe('septima-compute-module', () => {
+  test('fetches the content of the module to compute from the given callback function', async () => {
+    expect(await run('a', { a: `3+8` })).toEqual(11)
+  })
+  test('can use exported definitions from another module', async () => {
+    expect(await run('a', { a: `import * as b from 'b'; 3+b.eight`, b: `let eight = 8; {}` })).toEqual(11)
+  })
+  test('errors if the path to input from is not a string literal', async () => {
+    await expect(run('a', { a: `import * as foo from 500` })).rejects.toThrowError(
+      'Expected a string literal at (1:22..24) 500',
+    )
+  })
+  test('support the passing of args into the runtime', async () => {
+    expect(await run('a', { a: `args.x * args.y` }, { x: 5, y: 9 })).toEqual(45)
+  })
+  test('the args object is available only at the main module', async () => {
+    await expect(
+      run('a', { a: `import * as b from 'b'; args.x + '_' + b.foo`, b: `let foo = args.x ?? 'N/A'; {}` }, { x: 'Red' }),
+    ).rejects.toThrowError(/Symbol args was not found when evaluating/)
+  })
+})