septima-lang 0.0.14 → 0.0.15

package/dist/src/value.d.ts

@@ -1,7 +1,5 @@
-import { AstNode, Lambda, UnitId } from './ast-node';
+import { AstNode, Lambda } from './ast-node';
 import { CallEvaluator } from './find-array-method';
-import { Span } from './location';
-import * as Stack from './stack';
 import { SymbolTable } from './symbol-table';
 declare type LambdaEvaluator = (names: string[], ast: AstNode, table: SymbolTable) => Value;
 declare type Inner = {
@@ -22,16 +20,12 @@ declare type Inner = {
 } | {
     tag: 'num';
     val: number;
+} | {
+    tag: 'undef';
+    val: undefined;
 } | {
     tag: 'obj';
     val: Record<string, Value>;
-} | {
-    tag: 'sink';
-    val: undefined;
-    span?: Span;
-    trace?: Stack.T;
-    symbols?: SymbolTable;
-    unitId?: UnitId;
 } | {
     tag: 'str';
     val: string;
@@ -41,27 +35,12 @@ export declare class Value {
     private constructor();
     static bool(val: boolean): Value;
     static num(val: number): Value;
-    /**
-     * 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?: Span, trace?: Stack.T, symbols?: SymbolTable, unitId?: UnitId): Value;
     static str(val: string): Value;
+    static undef(): Value;
     static arr(val: Value[]): Value;
     static obj(val: Record<string, Value>): Value;
     static lambda(ast: Lambda, table: SymbolTable): Value;
     static foreign(f: (...args: Value[]) => unknown): Value;
-    isSink(): boolean;
     unwrap(): unknown;
     assertBool(): boolean;
     assertNum(): number;
@@ -73,17 +52,11 @@ export declare class Value {
         table: SymbolTable;
     };
     isLambda(): boolean;
+    isUndefined(): boolean;
     ifElse(positive: () => Value, negative: () => Value): Value;
-    bindToSpan(span: Span, unitId?: UnitId): Value;
-    trace(): AstNode[] | undefined;
-    symbols(): SymbolTable | undefined;
-    where(): {
-        span: Span;
-        unitId: string;
-    } | undefined;
+    coalesce(that: () => Value): Value;
     or(that: () => Value): Value;
     and(that: () => Value): Value;
-    unsink(that: () => Value): Value;
     equalsTo(that: Value): Value;
     not(): Value;
     private binaryNumericOperator;
@@ -125,6 +98,8 @@ export declare class Value {
     entries(): Value;
     fromEntries(): Value;
     toString(): string;
+    toBoolean(): boolean;
+    toNumber(): number;
     toJSON(): unknown;
     export(): unknown;
     static from(u: unknown): Value;