septima-lang 0.0.1

package/dist/src/runtime.js

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runtime = void 0;
+const ast_node_1 = require("./ast-node");
+const extract_message_1 = require("./extract-message");
+const fail_me_1 = require("./fail-me");
+const should_never_happen_1 = require("./should-never-happen");
+const Stack = __importStar(require("./stack"));
+const switch_on_1 = require("./switch-on");
+const value_1 = require("./value");
+class SymbolFrame {
+    constructor(symbol, placeholder, earlier) {
+        this.symbol = symbol;
+        this.placeholder = placeholder;
+        this.earlier = earlier;
+    }
+    lookup(sym) {
+        if (this.symbol === sym) {
+            const ret = this.placeholder.destination;
+            if (ret === undefined) {
+                throw new Error(`Unresolved definition: ${this.symbol}`);
+            }
+            return ret;
+        }
+        return this.earlier.lookup(sym);
+    }
+    export() {
+        const ret = this.earlier.export();
+        ret[this.symbol] = this.placeholder.destination?.export() ?? (0, fail_me_1.failMe)(`Unbounded symbol: ${this.symbol}`);
+        return ret;
+    }
+}
+class EmptySymbolTable {
+    lookup(sym) {
+        throw new Error(`Symbol ${sym} was not found`);
+    }
+    export() {
+        return {};
+    }
+}
+class Runtime {
+    constructor(root, verbosity = 'quiet', parser) {
+        this.root = root;
+        this.verbosity = verbosity;
+        this.parser = parser;
+        this.stack = undefined;
+    }
+    compute() {
+        const empty = new EmptySymbolTable();
+        const keys = value_1.Value.foreign(o => o.keys());
+        const entries = value_1.Value.foreign(o => o.entries());
+        const fromEntries = value_1.Value.foreign(o => o.fromEntries());
+        const lib = new SymbolFrame('Object', { destination: value_1.Value.obj({ keys, entries, fromEntries }) }, empty);
+        try {
+            const value = this.evalNode(this.root, lib);
+            return { value };
+        }
+        catch (e) {
+            const trace = [];
+            for (let curr = this.stack; curr; curr = curr?.next) {
+                trace.push(curr.ast);
+            }
+            return {
+                expressionTrace: trace,
+                errorMessage: (0, extract_message_1.extractMessage)(e),
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                stack: e.stack,
+            };
+        }
+    }
+    evalNode(ast, table) {
+        this.stack = Stack.push(ast, this.stack);
+        let ret = this.evalNodeImpl(ast, table);
+        if (ret.isSink() && !ret.span()) {
+            ret = ret.bindToSpan((0, ast_node_1.span)(ast));
+        }
+        (0, switch_on_1.switchOn)(this.verbosity, {
+            quiet: () => { },
+            trace: () => {
+                // eslint-disable-next-line no-console
+                console.log(`output of <|${(0, ast_node_1.show)(ast)}|> is ${JSON.stringify(ret)}  // ${ast.tag}`);
+            },
+        });
+        this.stack = Stack.pop(this.stack);
+        return ret;
+    }
+    evalNodeImpl(ast, table) {
+        if (ast.tag === 'topLevelExpression') {
+            let newTable = table;
+            for (const def of ast.definitions) {
+                const name = def.ident.t.text;
+                const placeholder = { destination: undefined };
+                newTable = new SymbolFrame(name, placeholder, newTable);
+                const v = this.evalNode(def.value, newTable);
+                placeholder.destination = v;
+            }
+            return this.evalNode(ast.computation, newTable);
+        }
+        if (ast.tag === 'binaryOperator') {
+            const lhs = this.evalNode(ast.lhs, table);
+            if (ast.operator === '||') {
+                return lhs.or(() => this.evalNode(ast.rhs, table));
+            }
+            if (ast.operator === '&&') {
+                return lhs.and(() => this.evalNode(ast.rhs, table));
+            }
+            if (ast.operator === '??') {
+                return lhs.unsink(() => this.evalNode(ast.rhs, table));
+            }
+            const rhs = this.evalNode(ast.rhs, table);
+            if (ast.operator === '!=') {
+                return lhs.equalsTo(rhs).not();
+            }
+            if (ast.operator === '==') {
+                return lhs.equalsTo(rhs);
+            }
+            if (ast.operator === '<=') {
+                const comp = lhs.order(rhs);
+                return comp.isToZero('<=');
+            }
+            if (ast.operator === '<') {
+                const comp = lhs.order(rhs);
+                return comp.isToZero('<');
+            }
+            if (ast.operator === '>=') {
+                const comp = lhs.order(rhs);
+                return comp.isToZero('>=');
+            }
+            if (ast.operator === '>') {
+                const comp = lhs.order(rhs);
+                return comp.isToZero('>');
+            }
+            if (ast.operator === '%') {
+                return lhs.modulo(rhs);
+            }
+            if (ast.operator === '*') {
+                return lhs.times(rhs);
+            }
+            if (ast.operator === '**') {
+                return lhs.power(rhs);
+            }
+            if (ast.operator === '+') {
+                return lhs.plus(rhs);
+            }
+            if (ast.operator === '-') {
+                return lhs.minus(rhs);
+            }
+            if (ast.operator === '/') {
+                return lhs.over(rhs);
+            }
+            (0, should_never_happen_1.shouldNeverHappen)(ast.operator);
+        }
+        if (ast.tag === 'unaryOperator') {
+            const operand = this.evalNode(ast.operand, table);
+            if (ast.operator === '!') {
+                return operand.not();
+            }
+            if (ast.operator === '+') {
+                // We intentionally do <0 + operand> instead of just <operand>. This is due to type-checking: the latter will
+                // evaluate to the operand as-is, making expression such as `+true` dynamically valid (which is not the desired
+                // behavior)
+                return value_1.Value.num(0).plus(operand);
+            }
+            if (ast.operator === '-') {
+                return operand.negate();
+            }
+            (0, should_never_happen_1.shouldNeverHappen)(ast.operator);
+        }
+        if (ast.tag === 'ident') {
+            return table.lookup(ast.t.text);
+        }
+        if (ast.tag === 'literal') {
+            if (ast.type === 'bool') {
+                // TODO(imaman): stricter checking of 'false'
+                return value_1.Value.bool(ast.t.text === 'true' ? true : false);
+            }
+            if (ast.type === 'num') {
+                return value_1.Value.num(Number(ast.t.text));
+            }
+            if (ast.type === 'sink!!') {
+                return value_1.Value.sink(undefined, this.stack, table);
+            }
+            if (ast.type === 'sink!') {
+                return value_1.Value.sink(undefined, this.stack);
+            }
+            if (ast.type === 'sink') {
+                return value_1.Value.sink();
+            }
+            if (ast.type === 'str') {
+                return value_1.Value.str(ast.t.text);
+            }
+            (0, should_never_happen_1.shouldNeverHappen)(ast.type);
+        }
+        if (ast.tag === 'arrayLiteral') {
+            const arr = [];
+            for (const curr of ast.parts) {
+                if (curr.tag === 'element') {
+                    arr.push(this.evalNode(curr.v, table));
+                }
+                else if (curr.tag === 'spread') {
+                    const v = this.evalNode(curr.v, table);
+                    arr.push(...v.assertArr());
+                }
+                else {
+                    (0, should_never_happen_1.shouldNeverHappen)(curr);
+                }
+            }
+            return value_1.Value.arr(arr);
+        }
+        if (ast.tag === 'objectLiteral') {
+            const entries = ast.parts.flatMap(at => {
+                if (at.tag === 'hardName') {
+                    return [[at.k.t.text, this.evalNode(at.v, table)]];
+                }
+                if (at.tag === 'computedName') {
+                    return [[this.evalNode(at.k, table).assertStr(), this.evalNode(at.v, table)]];
+                }
+                if (at.tag === 'spread') {
+                    const o = this.evalNode(at.o, table);
+                    return Object.entries(o.assertObj());
+                }
+                (0, should_never_happen_1.shouldNeverHappen)(at);
+            });
+            // TODO(imaman): verify type of all keys (strings, maybe also numbers)
+            return value_1.Value.obj(Object.fromEntries(entries));
+        }
+        if (ast.tag === 'lambda') {
+            return value_1.Value.lambda(ast, table);
+        }
+        if (ast.tag === 'functionCall') {
+            const argValues = ast.actualArgs.map(a => this.evalNode(a, table));
+            const callee = this.evalNode(ast.callee, table);
+            return this.call(callee, argValues);
+        }
+        if (ast.tag === 'if') {
+            const c = this.evalNode(ast.condition, table);
+            return c.ifElse(() => this.evalNode(ast.positive, table), () => this.evalNode(ast.negative, table));
+        }
+        if (ast.tag === 'dot') {
+            const rec = this.evalNode(ast.receiver, table);
+            if (rec === undefined || rec === null) {
+                throw new Error(`Cannot access attribute .${ast.ident.t.text} of ${rec}`);
+            }
+            return rec.access(ast.ident.t.text, (callee, args) => this.call(callee, args));
+        }
+        if (ast.tag === 'indexAccess') {
+            const rec = this.evalNode(ast.receiver, table);
+            const index = this.evalNode(ast.index, table);
+            return rec.access(index, (callee, args) => this.call(callee, args));
+        }
+        (0, should_never_happen_1.shouldNeverHappen)(ast);
+    }
+    call(callee, argValues) {
+        return callee.call(argValues, (names, body, lambdaTable) => {
+            if (names.length > argValues.length) {
+                throw new Error(`Arg list length mismatch: expected ${names.length} but got ${argValues.length}`);
+            }
+            const newTable = names.reduce((t, n, i) => new SymbolFrame(n, { destination: argValues[i] }, t), lambdaTable);
+            return this.evalNode(body, newTable);
+        });
+    }
+}
+exports.Runtime = Runtime;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"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"}

package/dist/src/scanner.d.ts

@@ -0,0 +1,22 @@
+import { Location } from './location';
+import { SourceCode } from './source-code';
+export interface Token {
+    readonly text: string;
+    readonly location: Location;
+}
+export declare class Scanner {
+    private readonly sourceCode;
+    private offset;
+    constructor(sourceCode: SourceCode);
+    get sourceRef(): string;
+    private curr;
+    private eatWhitespace;
+    eof(): boolean;
+    synopsis(): {
+        position: number;
+        lookingAt: string;
+    };
+    consume(r: RegExp | string, eatWhitespace?: boolean): Token;
+    consumeIf(r: RegExp | string, eatWhitespace?: boolean): Token | undefined;
+    private match;
+}

package/dist/src/scanner.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scanner = void 0;
+class Scanner {
+    constructor(sourceCode) {
+        this.sourceCode = sourceCode;
+        this.offset = 0;
+        this.eatWhitespace();
+    }
+    get sourceRef() {
+        return this.sourceCode.sourceRef(this.sourceCode.expandToEndOfLine({ offset: this.offset }));
+    }
+    curr() {
+        return this.sourceCode.input.substring(this.offset);
+    }
+    eatWhitespace() {
+        while (true) {
+            if (this.consumeIf(/\s*/, false)) {
+                continue;
+            }
+            if (this.consumeIf('//', false)) {
+                this.consume(/[^\n]*/, false);
+                continue;
+            }
+            return;
+        }
+    }
+    eof() {
+        return this.offset >= this.sourceCode.input.length;
+    }
+    synopsis() {
+        const c = this.curr();
+        let lookingAt = c.substring(0, 20);
+        if (lookingAt.length !== c.length) {
+            lookingAt = `${lookingAt}...`;
+        }
+        return {
+            position: this.offset,
+            lookingAt,
+        };
+    }
+    consume(r, eatWhitespace = true) {
+        const text = this.match(r);
+        if (text === undefined) {
+            throw new Error(`Expected ${r} ${this.sourceRef}`);
+        }
+        const offset = this.offset;
+        this.offset += text.length;
+        if (eatWhitespace) {
+            this.eatWhitespace();
+        }
+        return { location: { offset }, text };
+    }
+    consumeIf(r, eatWhitespace = true) {
+        const ret = this.match(r);
+        if (!ret) {
+            return undefined;
+        }
+        return this.consume(r, eatWhitespace);
+    }
+    match(r) {
+        if (typeof r === 'string') {
+            if (this.curr().startsWith(r)) {
+                return r;
+            }
+            return undefined;
+        }
+        const m = this.curr().match(r);
+        if (m && m.index === 0) {
+            return m[0];
+        }
+        return undefined;
+    }
+}
+exports.Scanner = Scanner;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/should-never-happen.d.ts

@@ -0,0 +1 @@
+export declare function shouldNeverHappen(n: never): never;

package/dist/src/should-never-happen.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldNeverHappen = void 0;
+function shouldNeverHappen(n) {
+    // This following line never gets executed. It is here just to make the compiler happy.
+    throw new Error(`This should never happen ${n}`);
+}
+exports.shouldNeverHappen = shouldNeverHappen;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hvdWxkLW5ldmVyLWhhcHBlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zaG91bGQtbmV2ZXItaGFwcGVuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLFNBQWdCLGlCQUFpQixDQUFDLENBQVE7SUFDeEMsdUZBQXVGO0lBQ3ZGLE1BQU0sSUFBSSxLQUFLLENBQUMsNEJBQTRCLENBQUMsRUFBRSxDQUFDLENBQUE7QUFDbEQsQ0FBQztBQUhELDhDQUdDIn0=

package/dist/src/source-code.d.ts

@@ -0,0 +1,19 @@
+import { AstNode } from './ast-node';
+import { Location, Location2d, Span } from './location';
+export declare class SourceCode {
+    readonly input: string;
+    constructor(input: string);
+    formatTrace(trace: AstNode[]): string;
+    sourceRefOfLocation(loc: Location): string;
+    sourceRef(span: Span | undefined): string;
+    formatSpan(span: Span): string;
+    private interestingPart;
+    resolveLocation(loc: Location): Location2d;
+    /**
+     * Returns a span starting a the given input location that runs all the way to the end of the line. Specifically, the
+     * returned span's `.to` location will point at the character (in the same line as `loc`) that is immediately before
+     * the terminating newline character.
+     */
+    expandToEndOfLine(loc: Location): Span;
+    lineAt(loc: Location): string;
+}

package/dist/src/source-code.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceCode = void 0;
+const ast_node_1 = require("./ast-node");
+class SourceCode {
+    constructor(input) {
+        this.input = input;
+    }
+    formatTrace(trace) {
+        const spacer = '  ';
+        const formatted = trace
+            .map(ast => this.sourceRef((0, ast_node_1.span)(ast)))
+            .reverse()
+            .join(`\n${spacer}`);
+        return `${spacer}${formatted}`;
+    }
+    sourceRefOfLocation(loc) {
+        return this.sourceRef(this.expandToEndOfLine(loc));
+    }
+    sourceRef(span) {
+        if (!span) {
+            return `at <unknown location>`;
+        }
+        return `at ${this.formatSpan(span)} ${this.interestingPart(span)}`;
+    }
+    formatSpan(span) {
+        const f = this.resolveLocation(span.from);
+        const t = this.resolveLocation(span.to);
+        if (f.line === t.line) {
+            return `(${f.line + 1}:${f.col + 1}..${t.col + 1})`;
+        }
+        return `(${f.line + 1}:${f.col + 1}..${t.line + 1}:${t.col + 1})`;
+    }
+    interestingPart(span) {
+        const f = this.resolveLocation(span.from);
+        const t = this.resolveLocation(span.to);
+        const strip = (s) => s.replace(/^[\n]*/, '').replace(/[\n]*$/, '');
+        const limit = 80;
+        const lineAtFrom = this.lineAt(span.from);
+        if (f.line !== t.line) {
+            return `${strip(lineAtFrom).substring(0, limit)}...`;
+        }
+        const stripped = strip(lineAtFrom.substring(f.col, t.col + 1));
+        if (stripped.length <= limit) {
+            return stripped;
+        }
+        return `${stripped.substring(0, limit)}...`;
+    }
+    resolveLocation(loc) {
+        const prefix = this.input.slice(0, loc.offset);
+        let line = 0;
+        for (let i = 0; i < prefix.length; ++i) {
+            const ch = prefix[i];
+            if (ch === '\n') {
+                line += 1;
+            }
+        }
+        let col = 0;
+        for (let i = prefix.length - 1; i >= 0; --i, ++col) {
+            const ch = prefix[i];
+            if (ch === '\n') {
+                break;
+            }
+        }
+        return { line, col };
+    }
+    /**
+     * Returns a span starting a the given input location that runs all the way to the end of the line. Specifically, the
+     * returned span's `.to` location will point at the character (in the same line as `loc`) that is immediately before
+     * the terminating newline character.
+     */
+    expandToEndOfLine(loc) {
+        let endOfLine = this.input.indexOf('\n', loc.offset);
+        if (endOfLine < 0) {
+            endOfLine = this.input.length - 1;
+        }
+        return { from: loc, to: { offset: endOfLine } };
+    }
+    lineAt(loc) {
+        const precedingNewline = this.input.lastIndexOf('\n', loc.offset);
+        // add a + 1 to skip over the '\n' character (it is not part of the line). Also works if precedingNewLine is -1 (no
+        // preceding newline exists)
+        const startOfLine = precedingNewline + 1;
+        const endOfLine = this.expandToEndOfLine(loc).to;
+        const ret = this.input.substring(startOfLine, endOfLine.offset + 1);
+        return ret;
+    }
+}
+exports.SourceCode = SourceCode;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/stack.d.ts

@@ -0,0 +1,11 @@
+import { AstNode } from './ast-node';
+export declare type T = {
+    ast: AstNode;
+    next: T;
+} | undefined;
+export declare function push(ast: AstNode, s: T): {
+    ast: AstNode;
+    next: T;
+};
+export declare function pop(s: T): T;
+export declare function empty(): T;

package/dist/src/stack.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.empty = exports.pop = exports.push = void 0;
+function push(ast, s) {
+    return { ast, next: s };
+}
+exports.push = push;
+function pop(s) {
+    if (typeof s === 'undefined') {
+        throw new Error(`Cannot pop from an empty stack`);
+    }
+    return s.next;
+}
+exports.pop = pop;
+function empty() {
+    return undefined;
+}
+exports.empty = empty;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3RhY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBR0EsU0FBZ0IsSUFBSSxDQUFDLEdBQVksRUFBRSxDQUFJO0lBQ3JDLE9BQU8sRUFBRSxHQUFHLEVBQUUsSUFBSSxFQUFFLENBQUMsRUFBRSxDQUFBO0FBQ3pCLENBQUM7QUFGRCxvQkFFQztBQUVELFNBQWdCLEdBQUcsQ0FBQyxDQUFJO0lBQ3RCLElBQUksT0FBTyxDQUFDLEtBQUssV0FBVyxFQUFFO1FBQzVCLE1BQU0sSUFBSSxLQUFLLENBQUMsZ0NBQWdDLENBQUMsQ0FBQTtLQUNsRDtJQUVELE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQTtBQUNmLENBQUM7QUFORCxrQkFNQztBQUVELFNBQWdCLEtBQUs7SUFDbkIsT0FBTyxTQUFTLENBQUE7QUFDbEIsQ0FBQztBQUZELHNCQUVDIn0=

package/dist/src/switch-on.d.ts

@@ -0,0 +1 @@
+export declare function switchOn<G, K extends string>(selector: K, cases: Record<K, () => G>): G;

package/dist/src/switch-on.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.switchOn = void 0;
+function switchOn(selector, cases) {
+    const f = cases[selector];
+    return f();
+}
+exports.switchOn = switchOn;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dpdGNoLW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N3aXRjaC1vbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxTQUFnQixRQUFRLENBQXNCLFFBQVcsRUFBRSxLQUF5QjtJQUNsRixNQUFNLENBQUMsR0FBRyxLQUFLLENBQUMsUUFBUSxDQUFDLENBQUE7SUFDekIsT0FBTyxDQUFDLEVBQUUsQ0FBQTtBQUNaLENBQUM7QUFIRCw0QkFHQyJ9

package/dist/src/symbol-table.d.ts

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

package/dist/src/symbol-table.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ltYm9sLXRhYmxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N5bWJvbC10YWJsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=