septima-lang 0.0.2 → 0.0.5

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) {
@@ -22,14 +63,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 +87,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 +111,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()
@@ -252,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 }
@@ -295,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)
     }
@@ -305,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
   }
 
   /**
@@ -326,6 +436,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 +450,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 +491,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 +514,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 +522,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 { AstNode, show, span, Unit } 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'
@@ -32,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 {
@@ -42,6 +47,10 @@ class EmptySymbolTable implements SymbolTable {
   export() {
     return {}
   }
+
+  exportValue(): Record<string, Value> {
+    return {}
+  }
 }
 
 export type Verbosity = 'quiet' | 'trace'
@@ -51,18 +60,27 @@ export class Runtime {
   constructor(
     private readonly root: AstNode,
     private readonly verbosity: Verbosity = 'quiet',
-    private readonly parser: Parser,
+    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())
     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)
+    }
+    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[] = []
@@ -95,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) {
@@ -109,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,10 +7,10 @@ export interface Token {
 }
 
 export class Scanner {
-  private offset = 0
-
-  constructor(private readonly sourceCode: SourceCode) {
-    this.eatWhitespace()
+  constructor(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

@@ -1,9 +1,11 @@
+import { Unit } from './ast-node'
 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 {
   /**
@@ -15,10 +17,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.
@@ -36,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
     }
@@ -48,30 +46,68 @@ 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() {}
+
+  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(verbosity: Verbosity = 'quiet'): Result {
-    const ast = parse(this.parser)
-    const runtime = new Runtime(ast, verbosity, this.parser)
+  compute(input: string, preimports: Record<string, string> = {}, verbosity: Verbosity = 'quiet'): Result {
+    const lib: Record<string, Value> = {}
+    for (const [importName, importCode] of Object.entries(preimports)) {
+      const sourceCode = new SourceCode(importCode)
+      const value = this.computeImpl(sourceCode, verbosity, {}, undefined)
+      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(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>,
+    moduleReader: undefined | ((m: string) => string),
+  ) {
+    const scanner = new Scanner(sourceCode)
+    const parser = new Parser(scanner)
+    const ast = parse(parser)
+
+    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) {
-      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)
   }
 }
 
-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',
+    )
+  })
+})