septima-lang 0.0.4 → 0.0.5

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) {
@@ -310,6 +351,18 @@ export class Parser {
   }
 
   literalOrIdent(): AstNode {
+    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!!')
     if (t) {
       return { tag: 'literal', type: 'sink!!', t }
@@ -353,7 +406,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 +420,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
   }
 
   /**

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,11 @@ 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,
   ) {}
 
-  compute() {
+  private buildInitialSymbolTable() {
     const empty = new EmptySymbolTable()
 
     const keys = Value.foreign(o => o.keys())
@@ -64,9 +75,12 @@ export class Runtime {
     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())
       return { value }
     } catch (e) {
       const trace: AstNode[] = []
@@ -99,7 +113,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())
+    }
+
+    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 +170,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'
@@ -33,7 +34,7 @@ export class Septima {
       ((r: ResultSink) => {
         throw new Error(r.message)
       })
-    const res = new Septima(input).compute()
+    const res = new Septima().compute(input)
     if (res.tag === 'ok') {
       return res.value
     }
@@ -45,13 +46,23 @@ 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): Result {
+    const input = moduleReader(moduleName)
+    const sourceCode = new SourceCode(input)
+    const value = this.computeImpl(sourceCode, 'quiet', {}, moduleReader)
+    if (!value.isSink()) {
+      return { value: value.export(), tag: 'ok' }
+    }
+    return new ResultSinkImpl(value, sourceCode)
+  }
+
+  compute(input: string, preimports: Record<string, string> = {}, verbosity: Verbosity = 'quiet'): 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 +71,31 @@ 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)
     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),
+  ) {
     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)
     const c = runtime.compute()
 
     if (c.value) {
@@ -85,7 +107,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,33 @@
+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>) {
+  const septima = new Septima()
+  const res = septima.computeModule(mainModule, (m: string) => inputs[m])
+  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',
+    )
+  })
+})

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}`)
@@ -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')
@@ -612,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!`,
@@ -632,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`,
@@ -794,17 +797,23 @@ 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)).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)).toMatchObject({ value: 35 })
     })
   })
   test.todo('support file names in locations')
@@ -825,4 +834,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}')
 })