yukigo 0.2.3 → 0.3.2

package/dist/interpreter/components/RuntimeContext.d.ts

@@ -1,35 +1,44 @@
-import { Environment, EnvStack, PrimitiveValue } from "yukigo-ast";
 import { FunctionRuntime } from "./runtimes/FunctionRuntime.js";
 import { LazyRuntime } from "./runtimes/LazyRuntime.js";
 import { ObjectRuntime } from "./runtimes/ObjectRuntime.js";
-export declare const DefaultConfiguration: Required<InterpreterConfig>;
-export type LogicSearchMode = "first" | "all" | "stream";
-export interface InterpreterConfig {
-    lazyLoading?: boolean;
-    debug?: boolean;
-    outputMode?: LogicSearchMode;
-    mutability?: boolean;
-}
+import { Environment, EnvStack } from "../utils.js";
+import { YuValue } from "../primitives/YuValue.js";
+import { YukigoHook } from "./hooks/YukigoHook.js";
+import { ExecutionCommand } from "./kernel/commands.js";
+import { InterpreterConfig } from "../../utils/helpers.js";
+import { Evaluator } from "./evaluators/BaseEvaluator.js";
+export declare const DefaultConfiguration: InterpreterConfig;
+export type EvaluatorFactory = (ctx: RuntimeContext) => Evaluator;
 export declare class UninitializedConfig extends Error {
     constructor();
 }
 export declare class ReinitializedConfig extends Error {
     constructor();
 }
+export interface LogicState {
+    variableCounter: number;
+    idToName: Map<number, string>;
+}
 export declare class RuntimeContext {
-    readonly config: InterpreterConfig | null;
+    readonly config: InterpreterConfig;
     env: EnvStack;
     lazyRuntime: LazyRuntime;
     funcRuntime: FunctionRuntime;
     objRuntime: ObjectRuntime;
-    constructor(config?: InterpreterConfig);
+    evaluatorFactory?: EvaluatorFactory;
+    logicState?: LogicState;
+    dispatchHook<K extends keyof YukigoHook>(eventName: K, ...args: Parameters<NonNullable<YukigoHook[K]>>): ReturnType<NonNullable<YukigoHook[K]>>[];
+    constructor(config?: Partial<InterpreterConfig>);
     setEnv(env: EnvStack): void;
+    forceValue(val: YuValue): ExecutionCommand;
     isDefined(name: string): boolean;
     pushEnv(frame?: Environment): void;
-    replace(name: string, value: PrimitiveValue, onReplace?: (env: Environment) => void): boolean;
+    replace(name: string, value: YuValue, onReplace?: (env: Environment) => void): boolean;
     popEnv(): void;
-    lookup(name: string): PrimitiveValue;
+    lookup(name: string): YuValue;
     remove(name: string): void;
-    define(name: string, value: PrimitiveValue): void;
-    clone(env?: EnvStack): EnvStack;
+    define(name: string, value: YuValue): void;
+    defineGlobal(name: string, value: YuValue): void;
+    cloneEnv(env?: EnvStack): EnvStack;
+    clone(env?: EnvStack): RuntimeContext;
 }

package/dist/interpreter/components/RuntimeContext.js

@@ -1,9 +1,12 @@
 import { FunctionRuntime } from "./runtimes/FunctionRuntime.js";
 import { LazyRuntime } from "./runtimes/LazyRuntime.js";
 import { ObjectRuntime } from "./runtimes/ObjectRuntime.js";
-import { createGlobalEnv } from "../utils.js";
+import { createGlobalEnv, } from "../utils.js";
 import { UnboundVariable } from "../errors.js";
+import { RuntimeFunction } from "../primitives/index.js";
+import { StepCommand, BindCommand, } from "./kernel/commands.js";
 export const DefaultConfiguration = {
+    nativeProviders: new Map(),
     lazyLoading: false,
     debug: false,
     outputMode: "first",
@@ -20,11 +23,24 @@ export class ReinitializedConfig extends Error {
     }
 }
 export class RuntimeContext {
-    config = null;
+    config = DefaultConfiguration;
     env;
     lazyRuntime;
     funcRuntime;
     objRuntime;
+    evaluatorFactory;
+    logicState;
+    dispatchHook(eventName, ...args) {
+        const results = [];
+        if (this.config.hooks) {
+            for (const hook of this.config.hooks) {
+                if (hook[eventName]) {
+                    results.push(hook[eventName](...args));
+                }
+            }
+        }
+        return results;
+    }
     constructor(config) {
         this.config = Object.freeze({ ...DefaultConfiguration, ...config });
         this.lazyRuntime = new LazyRuntime(this);
@@ -35,6 +51,14 @@ export class RuntimeContext {
     setEnv(env) {
         this.env = env;
     }
+    forceValue(val) {
+        if (val instanceof RuntimeFunction &&
+            val.arity === 0 &&
+            (val.pendingArgs?.length ?? 0) === 0) {
+            return new BindCommand(this.funcRuntime.apply(val, []), (res) => this.forceValue(res));
+        }
+        return new StepCommand(val);
+    }
     isDefined(name) {
         let current = this.env;
         while (current !== null) {
@@ -83,11 +107,26 @@ export class RuntimeContext {
     define(name, value) {
         this.env.head.set(name, value);
     }
-    clone(env) {
+    defineGlobal(name, value) {
+        let current = this.env;
+        while (current.tail !== null) {
+            current = current.tail;
+        }
+        current.head.set(name, value);
+    }
+    cloneEnv(env) {
         const target = env ?? this.env;
         return {
             head: new Map(target.head),
-            tail: this.env.tail,
+            tail: target.tail ? this.cloneEnv(target.tail) : null,
         };
     }
+    clone(env) {
+        const target = env ?? this.env;
+        const newCtx = new RuntimeContext(this.config);
+        newCtx.setEnv(this.cloneEnv(target));
+        newCtx.logicState = this.logicState; // share logic state
+        newCtx.evaluatorFactory = this.evaluatorFactory;
+        return newCtx;
+    }
 }

package/dist/interpreter/components/TestRunner.d.ts

@@ -1,18 +1,20 @@
-import { Assert, PrimitiveValue, Test, TestGroup, TraverseVisitor } from "yukigo-ast";
-import { InterpreterVisitor } from "./Visitor.js";
-import { CPSThunk } from "../trampoline.js";
+import { Assert, ASTNode, Test, TestGroup, Visitor } from "yukigo-ast";
+import { ExecutionCommand } from "./kernel/commands.js";
 import { LazyRuntime } from "./runtimes/LazyRuntime.js";
+import { YuValue } from "../primitives/YuValue.js";
+import { Evaluator } from "./evaluators/BaseEvaluator.js";
 export declare class FailedAssert extends Error {
-    actual?: PrimitiveValue;
-    expected?: PrimitiveValue;
-    constructor(actual?: PrimitiveValue, expected?: PrimitiveValue, message?: string);
+    actual?: YuValue | undefined;
+    expected?: YuValue | undefined;
+    constructor(actual?: YuValue | undefined, expected?: YuValue | undefined, message?: string);
 }
-export declare class TestRunner extends TraverseVisitor {
-    interpreter: InterpreterVisitor;
+export declare class TestRunner implements Visitor<ExecutionCommand> {
+    interpreter: Evaluator;
     private lazyRuntime;
-    constructor(interpreter: InterpreterVisitor, lazyRuntime: LazyRuntime);
-    run(node: TestGroup | Test | Assert): CPSThunk<void>;
-    visitTestGroup(node: TestGroup): CPSThunk<void>;
-    visitTest(node: Test): CPSThunk<void>;
-    visitAssert(node: Assert): CPSThunk<void>;
+    constructor(interpreter: Evaluator, lazyRuntime: LazyRuntime);
+    run(node: TestGroup | Test | Assert): ExecutionCommand;
+    visitTestGroup(node: TestGroup): ExecutionCommand;
+    visitTest(node: Test): ExecutionCommand;
+    visitAssert(node: Assert): ExecutionCommand;
+    fallback(node: ASTNode): ExecutionCommand;
 }

package/dist/interpreter/components/TestRunner.js

@@ -1,5 +1,15 @@
-import { TraverseVisitor, } from "yukigo-ast";
-import { idContinuation, trampoline, } from "../trampoline.js";
+import { Assert, Sequence, Exist, LogicConstraint, } from "yukigo-ast";
+import { LogicEngine } from "./logic/LogicEngine.js";
+import { StepCommand, BindCommand, FailCommand, } from "./kernel/commands.js";
+import { UnexpectedNode } from "../errors.js";
+import { YukigoKernel } from "./kernel/index.js";
+import { EqualityComparer } from "./EqualityComparer.js";
+import { YuBoolean } from "../primitives/scalars/YuBoolean.js";
+import { YuNil } from "../primitives/scalars/YuNil.js";
+import { YuString } from "../primitives/sequences/YuString.js";
+import { isTrue } from "../utils.js";
+import { LogicResult } from "../primitives/entities/LogicResult.js";
+import { RuntimeFunction } from "../primitives/entities/RuntimeFunction.js";
 export class FailedAssert extends Error {
     actual;
     expected;
@@ -10,77 +20,86 @@ export class FailedAssert extends Error {
         this.name = "FailedAssert";
     }
 }
-class AssertionVisitor extends TraverseVisitor {
+class AssertionVisitor {
     interpreter;
     negated;
-    lazyRuntime;
-    constructor(interpreter, negated, lazyRuntime) {
-        super();
+    constructor(interpreter, negated) {
         this.interpreter = interpreter;
         this.negated = negated;
-        this.lazyRuntime = lazyRuntime;
     }
     visitFailure(node) {
-        return (k) => () => {
-            let threw = false;
-            let actualError;
-            try {
-                // We use trampoline here to execute the function under test.
-                // While this is a nested trampoline, it's necessary to capture the error
-                // and isolate the test execution from the test runner's CPS flow.
-                trampoline(this.interpreter.evaluate(node.func, idContinuation));
-            }
-            catch (error) {
-                threw = true;
-                actualError = error.message;
+        let threw = false;
+        let actualError;
+        try {
+            new YukigoKernel(this.interpreter).run(this.interpreter.evaluate(node.func));
+        }
+        catch (error) {
+            threw = true;
+            actualError = new YuString(error.message);
+        }
+        if (!node.message) {
+            if (this.negated === threw) {
+                return new FailCommand(new FailedAssert(actualError, undefined, threw
+                    ? `Expected code NOT to fail, but it failed with "${actualError?.value}"`
+                    : `Expected code to fail, but it succeeded`));
             }
-            return this.interpreter.evaluate(node.message, (expectedError) => {
-                const passed = threw &&
-                    (expectedError === undefined ||
-                        actualError?.includes(expectedError));
-                if (this.negated === passed) {
-                    if (!threw) {
-                        throw new FailedAssert(undefined, expectedError, "Expected code to fail, but it succeeded");
-                    }
-                    else {
-                        throw new FailedAssert(actualError, expectedError, `Expected error message to contain "${expectedError}", but got "${actualError}"`);
-                    }
+            return new StepCommand(YuNil.getInstance());
+        }
+        return new BindCommand(this.interpreter.evaluate(node.message), (expectedError) => {
+            const isAnyException = expectedError instanceof RuntimeFunction ||
+                (expectedError && String(expectedError).includes("anyException"));
+            const expMsg = isAnyException || expectedError instanceof YuNil || !expectedError
+                ? undefined
+                : expectedError instanceof YuString
+                    ? expectedError.value
+                    : expectedError.toString();
+            const passed = threw &&
+                (expMsg === undefined || actualError?.value?.includes(expMsg));
+            if (this.negated === passed) {
+                if (!threw) {
+                    return new FailCommand(new FailedAssert(undefined, expectedError, "Expected code to fail, but it succeeded"));
                 }
-                return k(undefined);
-            });
-        };
+                else {
+                    return new FailCommand(new FailedAssert(actualError, expectedError, `Expected error message to contain "${expMsg}", but got "${actualError?.value}"`));
+                }
+            }
+            return new StepCommand(YuNil.getInstance());
+        });
     }
     visitEquality(node) {
-        return (k) => this.interpreter.evaluate(node.value, (value) => {
-            return () => this.interpreter.evaluate(node.expected, (expected) => {
-                this.lazyRuntime.deepEqual(value, expected, (passed) => {
-                    if (this.negated === passed) {
-                        throw new FailedAssert(value, expected, this.negated
+        return new BindCommand(this.interpreter.evaluate(node.value), (value) => {
+            return new BindCommand(this.interpreter.evaluate(node.expected), (expected) => {
+                return new BindCommand(EqualityComparer.compare(value, expected, this.interpreter.getContext()), (passed) => {
+                    const isPassed = isTrue(passed);
+                    if (this.negated === isPassed) {
+                        return new FailCommand(new FailedAssert(value, expected, this.negated
                             ? `Expected ${JSON.stringify(value)} NOT to be equal to ${JSON.stringify(expected)}`
-                            : `Expected ${JSON.stringify(expected)}, but got ${JSON.stringify(value)}`);
+                            : `Expected ${JSON.stringify(expected)}, but got ${JSON.stringify(value)}`));
                     }
-                    return k(undefined);
+                    return new StepCommand(YuNil.getInstance());
                 });
             });
         });
     }
     visitTruth(node) {
-        return (k) => this.interpreter.evaluate(node.body, (value) => {
-            const isTruthy = Boolean(value);
+        return new BindCommand(this.interpreter.evaluate(node.body), (value) => {
+            const isTruthy = isTrue(value) || (value instanceof LogicResult && value.success);
             if (this.negated === isTruthy) {
-                throw new FailedAssert(value, !this.negated, this.negated
+                return new FailCommand(new FailedAssert(value, new YuBoolean(!this.negated), this.negated
                     ? `Expected value to be falsy, but got ${JSON.stringify(value)}`
-                    : `Expected value to be truthy, but got ${JSON.stringify(value)}`);
+                    : `Expected value to be truthy, but got ${JSON.stringify(value)}`));
             }
-            return k(undefined);
+            return new StepCommand(YuNil.getInstance());
         });
     }
+    fallback(node) {
+        return new FailCommand(new UnexpectedNode(node.constructor.name, "AssertionVisitor"));
+    }
 }
-export class TestRunner extends TraverseVisitor {
+export class TestRunner {
     interpreter;
     lazyRuntime;
     constructor(interpreter, lazyRuntime) {
-        super();
         this.interpreter = interpreter;
         this.lazyRuntime = lazyRuntime;
     }
@@ -88,16 +107,30 @@ export class TestRunner extends TraverseVisitor {
         return node.accept(this);
     }
     visitTestGroup(node) {
-        return (k) => this.interpreter.evaluate(node.group, () => k(undefined));
+        return this.interpreter.evaluate(node.group);
     }
     visitTest(node) {
-        return (k) => this.interpreter.evaluate(node.body, () => k(undefined));
+        if (node.body.is(Sequence)) {
+            const hasLogicGoal = node.body.statements.some((stmt) => stmt.is(Exist) || stmt.is(LogicConstraint) || stmt.is(Assert));
+            if (hasLogicGoal) {
+                const engine = new LogicEngine(this.interpreter, this.interpreter.getContext());
+                const scope = new Map();
+                return engine.solveConjunction(node.body.statements, new Map(), scope);
+            }
+        }
+        return this.interpreter.evaluate(node.body);
     }
     visitAssert(node) {
-        return (k) => this.interpreter.evaluate(node.negated, (negatedVal) => {
-            const isNegated = Boolean(negatedVal);
-            const visitor = new AssertionVisitor(this.interpreter, isNegated, this.lazyRuntime);
-            return node.body.accept(visitor)(k);
+        const negatedCmd = node.negated
+            ? this.interpreter.evaluate(node.negated)
+            : new StepCommand(new YuBoolean(false));
+        return new BindCommand(negatedCmd, (negatedVal) => {
+            const isNegated = isTrue(negatedVal);
+            const visitor = new AssertionVisitor(this.interpreter, isNegated);
+            return node.body.accept(visitor);
         });
     }
+    fallback(node) {
+        return new FailCommand(new UnexpectedNode(node.constructor.name, "TestRunner"));
+    }
 }

package/dist/interpreter/components/evaluators/BaseEvaluator.d.ts

@@ -0,0 +1,19 @@
+import { ASTNode } from "yukigo-ast";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+import { YuValue } from "../../primitives/index.js";
+export type Constructor<T = {}> = new (...args: any[]) => T;
+export interface Evaluator {
+    evaluate(node: ASTNode): ExecutionCommand;
+    realizeList(val: YuValue): ExecutionCommand;
+    fallback(node: ASTNode): ExecutionCommand;
+    getContext(): RuntimeContext;
+}
+export declare class EvaluatorBase implements Evaluator {
+    context: RuntimeContext;
+    constructor(context: RuntimeContext);
+    getContext(): RuntimeContext;
+    evaluate(node: ASTNode): ExecutionCommand;
+    realizeList(val: any): ExecutionCommand;
+    fallback(node: ASTNode): ExecutionCommand;
+}

package/dist/interpreter/components/evaluators/BaseEvaluator.js

@@ -0,0 +1,20 @@
+import { FailCommand } from "../kernel/commands.js";
+import { UnexpectedNode } from "../../errors.js";
+export class EvaluatorBase {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    getContext() {
+        return this.context;
+    }
+    evaluate(node) {
+        return node.accept(this);
+    }
+    realizeList(val) {
+        return this.context.lazyRuntime.realizeList(val);
+    }
+    fallback(node) {
+        return new FailCommand(new UnexpectedNode(node.constructor.name, this.constructor.name));
+    }
+}

package/dist/interpreter/components/evaluators/ExpressionEvaluator.d.ts

@@ -0,0 +1,34 @@
+import { Application, Call, CompositionExpression, ConsExpression, DataExpression, Exist, FieldExpression, Findall, Forall, Goal, GuardedExpression, Lambda, LetInExpression, ListComprehension, New, Not, Generator as YuGenerator, Otherwise, RangeExpression, Send, TupleExpression, TypeCast } from "yukigo-ast";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { Constructor, EvaluatorBase } from "./BaseEvaluator.js";
+export declare function ExpressionEvaluator<TBase extends Constructor<EvaluatorBase>>(Base: TBase): {
+    new (...args: any[]): {
+        visitTupleExpr(node: TupleExpression): ExecutionCommand;
+        visitFieldExpression(node: FieldExpression): ExecutionCommand;
+        visitDataExpr(node: DataExpression): ExecutionCommand;
+        visitConsExpr(node: ConsExpression): ExecutionCommand;
+        visitLetInExpr(node: LetInExpression): ExecutionCommand;
+        visitCall(node: Call): ExecutionCommand;
+        visitOtherwise(node: Otherwise): ExecutionCommand;
+        visitCompositionExpression(node: CompositionExpression): ExecutionCommand;
+        visitLambda(node: Lambda): ExecutionCommand;
+        visitGuardedExpression(expr: GuardedExpression): ExecutionCommand;
+        visitApplication(node: Application): ExecutionCommand;
+        visitExist(node: Exist): ExecutionCommand;
+        visitNot(node: Not): ExecutionCommand;
+        visitFindall(node: Findall): ExecutionCommand;
+        visitForall(node: Forall): ExecutionCommand;
+        visitGoal(node: Goal): ExecutionCommand;
+        visitSend(node: Send): ExecutionCommand;
+        visitNew(node: New): ExecutionCommand;
+        visitListComprehension(node: ListComprehension): ExecutionCommand;
+        visitGenerator(node: YuGenerator): ExecutionCommand;
+        visitRangeExpression(node: RangeExpression): ExecutionCommand;
+        visitTypeCast(node: TypeCast): ExecutionCommand;
+        context: import("../RuntimeContext.js").RuntimeContext;
+        getContext(): import("../RuntimeContext.js").RuntimeContext;
+        evaluate(node: import("yukigo-ast").ASTNode): ExecutionCommand;
+        realizeList(val: any): ExecutionCommand;
+        fallback(node: import("yukigo-ast").ASTNode): ExecutionCommand;
+    };
+} & TBase;