septima-lang 0.0.1

package/dist/src/value.js

@@ -0,0 +1,634 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Value = void 0;
+const ast_node_1 = require("./ast-node");
+const fail_me_1 = require("./fail-me");
+const find_array_method_1 = require("./find-array-method");
+const find_string_method_1 = require("./find-string-method");
+const should_never_happen_1 = require("./should-never-happen");
+const switch_on_1 = require("./switch-on");
+function inspectValue(u) {
+    return JSON.stringify(u);
+}
+const badType = (expected, ...moreExpected) => (_u, _actual, v) => {
+    if (moreExpected.length === 0) {
+        throw new Error(`value type error: expected ${expected} but found ${inspectValue(v)}`);
+    }
+    throw new Error(`value type error: expected either ${moreExpected.join(', ')} or ${expected} but found ${inspectValue(v)}`);
+};
+/**
+ * Allows the caller to "see" the native value held by a Value object. The caller supplies the `cases` object
+ * which maps a function for each possible Value tag. Returns the return value of the function associated with the tag
+ * of `v`.
+ *
+ * In the code we should perfer to use `select()` over this one as it provides better handling of `sink` values.
+ *
+ * @param v the Value object to look into
+ * @param cases an object which maps Tag values to functions
+ * @returns the return value of the function mapped to the tag of `v`
+ */
+function selectRaw(v, cases) {
+    const inner = v.inner;
+    if (inner.tag === 'arr') {
+        return cases.arr(inner.val, inner.tag, v);
+    }
+    if (inner.tag === 'bool') {
+        return cases.bool(inner.val, inner.tag, v);
+    }
+    if (inner.tag === 'foreign') {
+        return cases.foreign(inner.val, inner.tag, v);
+    }
+    if (inner.tag === 'lambda') {
+        return cases.lambda(inner.val, inner.tag, v);
+    }
+    if (inner.tag === 'num') {
+        return cases.num(inner.val, inner.tag, v);
+    }
+    if (inner.tag === 'obj') {
+        return cases.obj(inner.val, inner.tag, v);
+    }
+    if (inner.tag === 'sink') {
+        // For sink we provide a default behavior of throwing an exception. Yet, the caller is encouraged to explicitly
+        // provide a `sink` case as there is broader context at the caller's side which makes it possible to provide more
+        // meaningful error messages.
+        if (!cases.sink) {
+            throw new Error(`Cannot evaluate a sink value`);
+        }
+        return cases.sink(inner.val, inner.tag, v);
+    }
+    if (inner.tag === 'str') {
+        return cases.str(inner.val, inner.tag, v);
+    }
+    (0, should_never_happen_1.shouldNeverHappen)(inner);
+}
+/**
+ * Allows the caller to "see" the native value held by a Value object. The caller supplies the `cases` object
+ * which maps a function for each possible Value tag. Returns the return value of the function associated with the tag
+ * of `v`.
+ *
+ * if `select()` is invoked on sink value (i.e., `Value.sink()`) it returns the sink value itself. This realizes the
+ * behavior that an expression involving a sink value evaluates to sink.
+ *
+ * @param v the Value object to look into
+ * @param cases an object which maps Tag values to functions
+ * @returns the return value of the function mapped to the tag of `v`
+ */
+function select(v, cases) {
+    if (v.isSink()) {
+        return v;
+    }
+    return Value.from(selectRaw(v, cases));
+}
+class Value {
+    constructor(inner) {
+        this.inner = inner;
+    }
+    static bool(val) {
+        return new Value({ val, tag: 'bool' });
+    }
+    static num(val) {
+        return new Value({ val, tag: 'num' });
+    }
+    /**
+     * Returns a Value which is essentially a "sink": (almost) every computation involving a sink evaluates to sink. A few
+     * quick examples: `5+sink`, `sink.x`, `sink()`, `Object.keys(sink)`, `if (sink) 4 else 8` all evaluate to `sink`. The
+     * raitonale is that once an expression evaluates to `sink` all expressions depending on it also evaluate to `sink`.
+     *
+     * There are however a few (intentional) exemptions:
+     * (i) a sink can be passed as an actual parameter in a function call. Hence `(fun (x,y) y)(sink, 5)` will evaluate
+     *    to `5`.
+     * (ii) a sink can be compared with itself.
+     * (iii) in `if()` expressions, only one of the branches is evlauated (based on the condition's value). As a result,
+     *    evluation of a sink-producing branch can be skipping. Specifically, `if (true) 5 else sink` evaluates to `5`.
+     * (iv) in `||` and `&&` expressions, the evaluation of the right hand side can be skipped. Specifically,
+     *    `true || sink` evaluates to `true` and `false && sink` evaluates to `false`.
+     */
+    static sink(span, trace, symbols) {
+        return new Value({
+            val: undefined,
+            tag: 'sink',
+            ...(span ? { span } : {}),
+            ...(trace ? { trace } : {}),
+            ...(symbols ? { symbols } : {}),
+        });
+    }
+    static str(val) {
+        return new Value({ val, tag: 'str' });
+    }
+    static arr(val) {
+        return new Value({ val, tag: 'arr' });
+    }
+    static obj(val) {
+        return new Value({ val, tag: 'obj' });
+    }
+    static lambda(ast, table) {
+        return new Value({ val: { ast, table }, tag: 'lambda' });
+    }
+    static foreign(f) {
+        return new Value({ tag: 'foreign', val: f });
+    }
+    isSink() {
+        return this.inner.tag === 'sink';
+    }
+    unwrap() {
+        return this.inner.val;
+    }
+    assertBool() {
+        const err = badType('bool');
+        return selectRaw(this, {
+            arr: err,
+            bool: a => a,
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: err,
+            sink: err,
+            str: err,
+        });
+    }
+    assertNum() {
+        const err = badType('num');
+        return selectRaw(this, {
+            arr: err,
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: a => a,
+            obj: err,
+            sink: err,
+            str: err,
+        });
+    }
+    assertStr() {
+        const err = badType('str');
+        return selectRaw(this, {
+            arr: err,
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: err,
+            sink: err,
+            str: a => a,
+        });
+    }
+    assertArr() {
+        const err = badType('arr');
+        return selectRaw(this, {
+            arr: a => a,
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: err,
+            sink: err,
+            str: err,
+        });
+    }
+    assertObj() {
+        const err = badType('obj');
+        return selectRaw(this, {
+            arr: err,
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: a => a,
+            sink: err,
+            str: err,
+        });
+    }
+    assertLambda() {
+        const err = badType('lambda');
+        return selectRaw(this, {
+            arr: err,
+            bool: err,
+            foreign: err,
+            lambda: a => a,
+            num: err,
+            obj: err,
+            sink: err,
+            str: err,
+        });
+    }
+    isLambda() {
+        return this.inner.tag === 'lambda';
+    }
+    ifElse(positive, negative) {
+        const err = badType('bool');
+        return select(this, {
+            arr: err,
+            bool: c => (c ? positive() : negative()),
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: err,
+            str: err,
+        });
+    }
+    bindToSpan(span) {
+        const inner = this.inner;
+        if (inner.tag !== 'sink') {
+            throw new Error(`Not supported on type ${this.inner.tag}`);
+        }
+        return Value.sink(span, inner.trace, inner.symbols);
+    }
+    trace() {
+        const inner = this.inner;
+        if (inner.tag !== 'sink') {
+            return undefined;
+        }
+        const ret = [];
+        for (let curr = inner.trace; curr !== undefined; curr = curr?.next) {
+            ret.push(curr.ast);
+        }
+        return ret.length === 0 ? undefined : ret;
+    }
+    symbols() {
+        const inner = this.inner;
+        if (inner.tag !== 'sink') {
+            return undefined;
+        }
+        return inner.symbols;
+    }
+    span() {
+        const inner = this.inner;
+        if (inner.tag !== 'sink') {
+            return undefined;
+        }
+        return inner.span;
+    }
+    or(that) {
+        const err = badType('bool');
+        return select(this, {
+            arr: err,
+            bool: lhs => lhs ||
+                select(that(), {
+                    arr: err,
+                    bool: rhs => rhs,
+                    foreign: err,
+                    lambda: err,
+                    num: err,
+                    obj: err,
+                    str: err,
+                }),
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: err,
+            str: err,
+        });
+    }
+    and(that) {
+        const err = badType('bool');
+        return select(this, {
+            arr: err,
+            bool: lhs => lhs &&
+                select(that(), {
+                    arr: err,
+                    bool: rhs => rhs,
+                    foreign: err,
+                    lambda: err,
+                    num: err,
+                    obj: err,
+                    str: err,
+                }),
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: err,
+            str: err,
+        });
+    }
+    unsink(that) {
+        if (this.isSink()) {
+            return that();
+        }
+        return this;
+    }
+    equalsTo(that) {
+        if (this.inner.tag !== that.inner.tag) {
+            return Value.bool(false);
+        }
+        // TODO(imaman): much better comparison is needed here
+        const b = JSON.stringify(this.inner.val) === JSON.stringify(that.inner.val);
+        return Value.bool(b);
+    }
+    not() {
+        const err = badType('bool');
+        return select(this, {
+            arr: err,
+            bool: lhs => !lhs,
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: err,
+            str: err,
+        });
+    }
+    binaryNumericOperator(a, b, f) {
+        const err = badType('num');
+        return select(a, {
+            arr: err,
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: lhs => select(b, {
+                arr: err,
+                bool: err,
+                foreign: err,
+                lambda: err,
+                num: rhs => f(lhs, rhs),
+                obj: err,
+                str: err,
+            }),
+            obj: err,
+            str: err,
+        });
+    }
+    plus(that) {
+        const errNum = badType('num');
+        return select(this, {
+            arr: errNum,
+            bool: errNum,
+            foreign: errNum,
+            lambda: errNum,
+            num: lhs => select(that, {
+                arr: errNum,
+                bool: errNum,
+                foreign: errNum,
+                lambda: errNum,
+                num: rhs => lhs + rhs,
+                obj: errNum,
+                str: errNum,
+            }),
+            obj: errNum,
+            str: lhs => select(that, {
+                arr: rhs => lhs + rhs,
+                bool: rhs => lhs + rhs,
+                foreign: rhs => lhs + rhs,
+                lambda: rhs => lhs + rhs,
+                num: rhs => lhs + rhs,
+                obj: rhs => lhs + rhs,
+                str: rhs => lhs + rhs,
+            }),
+        });
+    }
+    minus(that) {
+        return this.binaryNumericOperator(this, that, (a, b) => a - b);
+    }
+    times(that) {
+        return this.binaryNumericOperator(this, that, (a, b) => a * b);
+    }
+    power(that) {
+        return this.binaryNumericOperator(this, that, (a, b) => a ** b);
+    }
+    over(that) {
+        return this.binaryNumericOperator(this, that, (a, b) => a / b);
+    }
+    modulo(that) {
+        return this.binaryNumericOperator(this, that, (a, b) => a % b);
+    }
+    negate() {
+        return Value.num(0).minus(this);
+    }
+    isToZero(comparator) {
+        const err = badType('num');
+        return select(this, {
+            arr: err,
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: n => (0, switch_on_1.switchOn)(comparator, {
+                '<': () => Value.bool(n < 0),
+                '<=': () => Value.bool(n <= 0),
+                '==': () => Value.bool(n == 0),
+                '!=': () => Value.bool(n !== 0),
+                '>=': () => Value.bool(n >= 0),
+                '>': () => Value.bool(n > 0),
+            }),
+            obj: err,
+            str: err,
+        });
+    }
+    isTrue() {
+        const err = badType('bool');
+        return selectRaw(this, {
+            arr: err,
+            bool: b => b,
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: err,
+            sink: err,
+            str: err,
+        });
+    }
+    isZero() {
+        const err = badType('num');
+        return selectRaw(this, {
+            arr: err,
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: n => n === 0,
+            obj: err,
+            sink: err,
+            str: err,
+        });
+    }
+    /**
+     * Determines the order beteween `this` and the given argument (`that`). The behavior of this method is dictated by
+     * the following principles:
+     *
+     * (i) if a < b then b >= a (i.e., it provides a consistent answer regardless of the whether `this` is `a`
+     *    and `that` is `b` or vice versa)
+     * (ii) ordering two values of different type result in runtime error.
+     * (iii) orderingg a value with itself evaluates to `0`
+     *
+     * Principles (i) and (iii) realizes the intuitive behavior of comparisons. (ii) realizes the idea that
+     * "one cannot compare oranges and apples". This is essentially a design decision. We could have gone with defining
+     * some order between types (the tag of a Value object), but we feel that a saner approach is to say "we do not know
+     * how to sort an array containing numbers and booleans".
+     *
+     * IMPORTANT: these principles overpower other principles. In parituclar, the principles that "an expression with
+     * sink evaluates to sink" is trumped by comparison principle (ii)
+     *
+     * @param that
+     * @returns
+     */
+    order(that) {
+        const err = (_u, t) => {
+            throw new Error(`Cannot compare a value of type ${t}`);
+        };
+        if (this.inner.tag !== that.inner.tag) {
+            throw new Error(`Cannot compare a ${this.inner.tag} value with a value of another type (${that.inner.tag})`);
+        }
+        return select(this, {
+            arr: err,
+            bool: lhs => {
+                const rhs = that.assertBool();
+                return lhs && !rhs ? 1 : !lhs && rhs ? -1 : 0;
+            },
+            foreign: err,
+            lambda: err,
+            num: () => {
+                const d = this.minus(that).assertNum();
+                return d < 0 ? -1 : d > 0 ? 1 : 0;
+            },
+            obj: err,
+            str: a => {
+                const rhs = that.assertStr();
+                const d = a.localeCompare(rhs);
+                return d < 0 ? -1 : d > 0 ? 1 : 0;
+            },
+        });
+    }
+    static toStringOrNumber(input) {
+        if (typeof input === 'string') {
+            return input;
+        }
+        const err = badType('str', 'num');
+        return selectRaw(input, {
+            arr: err,
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: a => a,
+            obj: err,
+            sink: err,
+            str: a => a,
+        });
+    }
+    access(indexValue, callEvaluator) {
+        const err = badType('obj', 'str', 'arr');
+        return select(this, {
+            arr: a => {
+                if (typeof indexValue === 'string') {
+                    return (0, find_array_method_1.findArrayMethod)(a, indexValue, callEvaluator);
+                }
+                const i = indexValue.assertNum();
+                if (i < 0 || i > a.length) {
+                    throw new Error(`array index (${i}) is out of bounds (length = ${a.length})`);
+                }
+                return a[i];
+            },
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: o => o[Value.toStringOrNumber(indexValue)],
+            str: s => (0, find_string_method_1.findStringMethod)(s, indexValue),
+        });
+    }
+    call(args, evaluator) {
+        const err = badType('lambda', 'foreign');
+        return select(this, {
+            arr: err,
+            bool: err,
+            foreign: f => from(f(...args)),
+            lambda: l => evaluator(l.ast.formalArgs.map(a => a.t.text), l.ast.body, l.table),
+            num: err,
+            obj: err,
+            str: err,
+        });
+    }
+    keys() {
+        const err = badType('obj');
+        return select(this, {
+            arr: err,
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: a => Object.keys(a),
+            str: err,
+        });
+    }
+    entries() {
+        const err = badType('obj');
+        return select(this, {
+            arr: err,
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: a => Object.entries(a),
+            str: err,
+        });
+    }
+    fromEntries() {
+        const err = badType('arr');
+        return select(this, {
+            arr: a => Object.fromEntries(a.map(x => selectRaw(x, {
+                arr: pair => {
+                    pair.length === 2 || (0, fail_me_1.failMe)(`each entry must be a [key, value] pair`);
+                    return [pair[0].assertStr(), pair[1]];
+                },
+                bool: err,
+                foreign: err,
+                lambda: err,
+                num: err,
+                obj: err,
+                sink: err,
+                str: err,
+            }))),
+            bool: err,
+            foreign: err,
+            lambda: err,
+            num: err,
+            obj: err,
+            str: err,
+        });
+    }
+    toString() {
+        return this.inner.val?.toString() ?? 'sink';
+    }
+    toJSON() {
+        const copy = (v) => {
+            return selectRaw(v, {
+                arr: a => a.map(x => copy(x)),
+                bool: a => a,
+                foreign: a => a.toString(),
+                lambda: a => (0, ast_node_1.show)(a.ast),
+                num: a => a,
+                obj: a => Object.fromEntries(Object.entries(a).map(([k, x]) => [k, copy(x)])),
+                sink: () => undefined,
+                str: a => a,
+            });
+        };
+        return copy(this);
+    }
+    export() {
+        return this.toJSON();
+    }
+    static from(u) {
+        return from(u);
+    }
+}
+exports.Value = Value;
+function from(u) {
+    if (u instanceof Value) {
+        return u;
+    }
+    if (typeof u === 'boolean') {
+        return Value.bool(u);
+    }
+    if (typeof u === 'number') {
+        return Value.num(u);
+    }
+    if (typeof u === 'string') {
+        return Value.str(u);
+    }
+    if (Array.isArray(u)) {
+        return Value.arr(u.map(curr => from(curr)));
+    }
+    if (typeof u === 'undefined') {
+        return Value.sink();
+    }
+    if (u && typeof u === 'object') {
+        return Value.obj(Object.fromEntries(Object.entries(u).map(([k, v]) => [k, from(v)])));
+    }
+    throw new Error(`cannot convert ${JSON.stringify(u)} to Value`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"value.js","sourceRoot":"","sources":["../../src/value.ts"],"names":[],"mappings":"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"}

package/dist/tests/cdl.spec.d.ts

@@ -0,0 +1 @@
+export {};