yukigo 0.2.2 → 0.3.1

package/dist/interpreter/primitives/sequences/YuArray.js

@@ -0,0 +1,150 @@
+import { YuValue } from "../YuValue.js";
+import { BindCommand, StepCommand, } from "../../components/kernel/commands.js";
+import { YuNil } from "../scalars/YuNil.js";
+import { UnsupportedOperation } from "../../errors.js";
+import { LazyStepResult } from "../entities/LazyList.js";
+import { YuNumber, YuString } from "../index.js";
+import { boolean, compareResult, number, raise } from "../../utils.js";
+export class YuArray extends YuValue {
+    items;
+    index;
+    constructor(items, index = 0) {
+        super();
+        this.items = items;
+        this.index = index;
+    }
+    get asSequence() {
+        return this;
+    }
+    get asComparable() {
+        return this;
+    }
+    *[Symbol.iterator]() {
+        for (let i = this.index; i < this.items.length; i++) {
+            yield this.items[i];
+        }
+    }
+    size() {
+        return number(this.items.length);
+    }
+    step() {
+        if (this.index >= this.items.length) {
+            return new StepCommand(YuNil.getInstance());
+        }
+        const item = this.items[this.index];
+        const tail = new YuArray(this.items, this.index + 1);
+        return new StepCommand(new LazyStepResult(item, tail));
+    }
+    concat(other) {
+        const seq = other.asSequence;
+        if (!seq)
+            return raise(new UnsupportedOperation(other, "concat"));
+        return seq.concatWithArray(this);
+    }
+    concatWithArray(arr) {
+        return new StepCommand(new YuArray([...arr, ...this]));
+    }
+    concatWithString(str) {
+        return new StepCommand(new YuString(this.toJSON() + str.toJSON()));
+    }
+    at(index) {
+        return this.items[this.index + index];
+    }
+    flat() {
+        return new YuArray([...this].flatMap((item) => {
+            const seq = item.asSequence;
+            return seq instanceof YuArray ? [...seq] : [item];
+        }));
+    }
+    equals(other) {
+        const c = other.asComparable;
+        if (!c)
+            return boolean(false);
+        return c.equalsWithArray(this);
+    }
+    equalsWithNumber() {
+        return boolean(false);
+    }
+    equalsWithBoolean() {
+        return boolean(false);
+    }
+    equalsWithString() {
+        return boolean(false);
+    }
+    equalsWithArray(left) {
+        return new BindCommand(left.size(), (res) => {
+            const leftSize = res.asNumeric?.asComparable;
+            if (!leftSize || !leftSize.equals(new YuNumber(this.items.length)))
+                return boolean(false);
+            const compareNext = (index) => {
+                if (compareResult(leftSize.compare(new YuNumber(index)), (res) => res >= 0)) {
+                    return boolean(true);
+                }
+                return new BindCommand(left.at(index).equals(this.at(index)), (res) => {
+                    if (!res.toJSON())
+                        return boolean(false);
+                    return compareNext(index + 1);
+                });
+            };
+            return compareNext(0);
+        });
+    }
+    equalsWithNil() {
+        return boolean(false);
+    }
+    compare(other) {
+        const c = other.asComparable;
+        if (!c)
+            return raise(new UnsupportedOperation(other, "compare"));
+        return c.compareWithArray(this);
+    }
+    compareWithNumber() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithBoolean() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithString() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithArray(left) {
+        const a = [...left];
+        const b = [...this];
+        const minLen = Math.min(a.length, b.length);
+        const compareNext = (index) => {
+            if (index >= minLen) {
+                return new StepCommand(new YuNumber(a.length - b.length));
+            }
+            return new BindCommand(a[index].compare(b[index]), (res) => {
+                const cmp = res.toJSON();
+                if (cmp !== 0) {
+                    return new StepCommand(res);
+                }
+                return compareNext(index + 1);
+            });
+        };
+        return compareNext(0);
+    }
+    compareWithNil() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    toJSON(keyOrSeen) {
+        const seen = keyOrSeen instanceof Set ? keyOrSeen : new Set();
+        if (seen.has(this))
+            return "[Circular]";
+        seen.add(this);
+        const result = this.index === 0
+            ? this.items.map((i) => i.toJSON(seen))
+            : this.items.slice(this.index).map((i) => i.toJSON(seen));
+        seen.delete(this);
+        return result;
+    }
+    toString(seen = new Set()) {
+        if (seen.has(this))
+            return "[Circular]";
+        seen.add(this);
+        const result = `[${[...this].map((i) => i.toString(seen)).join(", ")}]`;
+        seen.delete(this);
+        return result;
+    }
+}

package/dist/interpreter/primitives/sequences/YuString.d.ts

@@ -0,0 +1,40 @@
+import { YuValue } from "../YuValue.js";
+import { YuChar } from "../scalars/YuChar.js";
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+import { YuNumber } from "../scalars/YuNumber.js";
+import { YuArray } from "./YuArray.js";
+import { Comparable, Sequence, Summable, YuComparable, YuSequence, YuSummable } from "../capabilities.js";
+export declare class YuString extends YuValue implements Sequence, Summable, Comparable {
+    readonly value: string;
+    readonly index: number;
+    constructor(value: string, index?: number);
+    get asSequence(): YuSequence;
+    get asSummable(): YuSummable;
+    get asComparable(): YuComparable;
+    [Symbol.iterator](): Iterator<YuChar>;
+    step(): ExecutionCommand;
+    size(): ExecutionCommand;
+    plus(other: YuValue): ExecutionCommand;
+    plusWithNumber(left: YuNumber): ExecutionCommand;
+    plusWithString(left: YuString): ExecutionCommand;
+    split(): ExecutionCommand;
+    concat(other: YuValue): ExecutionCommand;
+    concatWithString(str: YuString): ExecutionCommand;
+    concatWithArray(arr: YuArray): ExecutionCommand;
+    realize(): ExecutionCommand;
+    equals(other: YuValue): ExecutionCommand;
+    contains(other: YuValue): ExecutionCommand;
+    equalsWithNumber(left: YuNumber): ExecutionCommand;
+    equalsWithBoolean(): ExecutionCommand;
+    equalsWithString(left: YuString): ExecutionCommand;
+    equalsWithArray(): ExecutionCommand;
+    equalsWithNil(): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    compareWithNumber(left: YuNumber): ExecutionCommand;
+    compareWithBoolean(): ExecutionCommand;
+    compareWithString(left: YuString): ExecutionCommand;
+    compareWithArray(): ExecutionCommand;
+    compareWithNil(): ExecutionCommand;
+    toJSON(): string;
+    toString(): string;
+}

package/dist/interpreter/primitives/sequences/YuString.js

@@ -0,0 +1,130 @@
+import { YuValue } from "../YuValue.js";
+import { YuChar } from "../scalars/YuChar.js";
+import { StepCommand, } from "../../components/kernel/commands.js";
+import { YuNil } from "../scalars/YuNil.js";
+import { YuNumber } from "../scalars/YuNumber.js";
+import { YuArray } from "./YuArray.js";
+import { UnsupportedOperation } from "../../errors.js";
+import { LazyStepResult, YuBoolean } from "../index.js";
+import { boolean, number, raise } from "../../utils.js";
+export class YuString extends YuValue {
+    value;
+    index;
+    constructor(value, index = 0) {
+        super();
+        this.value = value;
+        this.index = index;
+    }
+    get asSequence() {
+        return this;
+    }
+    get asSummable() {
+        return this;
+    }
+    get asComparable() {
+        return this;
+    }
+    *[Symbol.iterator]() {
+        for (let i = this.index; i < this.value.length; i++) {
+            yield new YuChar(this.value[i]);
+        }
+    }
+    step() {
+        if (this.index >= this.value.length) {
+            return new StepCommand(YuNil.getInstance());
+        }
+        const char = new YuChar(this.value[this.index]);
+        const tail = new YuString(this.value, this.index + 1);
+        return new StepCommand(new LazyStepResult(char, tail));
+    }
+    size() {
+        return number(this.value.length);
+    }
+    plus(other) {
+        const s = other.asSummable;
+        if (!s)
+            return raise(new UnsupportedOperation(other, "plus"));
+        return s.plusWithString(this);
+    }
+    plusWithNumber(left) {
+        return new StepCommand(new YuString(left.toJSON().toString() + this.toJSON()));
+    }
+    plusWithString(left) {
+        return new StepCommand(new YuString(left.toJSON() + this.toJSON()));
+    }
+    split() {
+        const items = this.toJSON()
+            .split("")
+            .map((char) => new YuChar(char));
+        return new StepCommand(new YuArray(items));
+    }
+    concat(other) {
+        const seq = other.asSequence;
+        if (!seq)
+            return raise(new UnsupportedOperation(other, "concat"));
+        return seq.concatWithString(this);
+    }
+    concatWithString(str) {
+        return new StepCommand(new YuString(str.toJSON() + this.toJSON()));
+    }
+    concatWithArray(arr) {
+        return new StepCommand(new YuString(arr.toString()));
+    }
+    realize() {
+        return this.split();
+    }
+    equals(other) {
+        const c = other.asComparable;
+        if (!c)
+            return boolean(false);
+        return c.equalsWithString(this);
+    }
+    contains(other) {
+        if (other instanceof YuString) {
+            return boolean(this.value.includes(other.value));
+        }
+        return raise(new UnsupportedOperation(other, "contains"));
+    }
+    equalsWithNumber(left) {
+        return new StepCommand(new YuBoolean(left.value.toString() === this.toJSON()));
+    }
+    equalsWithBoolean() {
+        return boolean(false);
+    }
+    equalsWithString(left) {
+        return boolean(left.toJSON() === this.toJSON());
+    }
+    equalsWithArray() {
+        return boolean(false);
+    }
+    equalsWithNil() {
+        return boolean(false);
+    }
+    compare(other) {
+        const c = other.asComparable;
+        if (!c)
+            return raise(new UnsupportedOperation(other, "compare"));
+        return c.compareWithString(this);
+    }
+    compareWithNumber(left) {
+        return new StepCommand(new YuNumber(left.value - Number(this.toJSON())));
+    }
+    compareWithBoolean() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithString(left) {
+        return new StepCommand(new YuNumber(left.toJSON().localeCompare(this.toJSON())));
+    }
+    compareWithArray() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithNil() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    toJSON() {
+        return this.index === 0 ? this.value : this.value.slice(this.index);
+    }
+    toString() {
+        return this.toJSON();
+    }
+}

package/dist/interpreter/utils.d.ts

@@ -1,11 +1,24 @@
-import { LazyList, PrimitiveValue, Environment, EnvStack, ASTNode } from "yukigo-ast";
-import { Continuation, Thunk } from "./trampoline.js";
-export interface ExpressionEvaluator {
-    evaluate<R = PrimitiveValue>(node: ASTNode, cont: Continuation<PrimitiveValue, R>): Thunk<R>;
-}
-export declare function createStream(generator: () => Generator<PrimitiveValue, void, unknown>): LazyList;
-export declare function isArrayOfNumbers(arr: PrimitiveValue[]): arr is number[];
-export declare function generateRange(start: number, end: number, step: number): number[];
-export declare function createEnv(bindings: [string, PrimitiveValue][]): Environment;
+import { ExecutionCommand, RaiseCommand, StepCommand } from "./components/kernel/commands.js";
+import { RuntimeContext } from "./components/RuntimeContext.js";
+import { YuValue, YuNumber, LazyList } from "./primitives/index.js";
+import { InterpreterError } from "./errors.js";
+export declare const raise: (err: InterpreterError) => RaiseCommand;
+export declare const error: (ctx: string, msg: string) => InterpreterError;
+export declare const boolean: (condition: boolean) => StepCommand;
+export declare const number: (num: number) => StepCommand;
+export declare const not: (command: ExecutionCommand) => ExecutionCommand;
+export declare const isTrue: (val: unknown) => boolean;
+export declare const compareResult: (command: ExecutionCommand, predicate: (num: number) => boolean) => ExecutionCommand;
+export type NativeExtension = (self: YuValue, args: YuValue[], ctx: RuntimeContext) => ExecutionCommand;
+export type PrimitiveThunk = () => YuValue;
+export type Environment = Map<string, YuValue>;
+export type EnvStack = {
+    head: Environment;
+    tail: EnvStack | null;
+};
+export declare function isArrayOfNumbers(arr: YuValue): boolean;
+export declare function generateRange(start: number, end: number, step: number): YuNumber[];
+export declare function createEnv(bindings: [string, YuValue][]): Environment;
 export declare function createGlobalEnv(): EnvStack;
-export declare function getYukigoType(val: PrimitiveValue): string;
+export declare function getYukigoType(val: YuValue): string;
+export declare function createStream(generator: () => ExecutionCommand): LazyList;

package/dist/interpreter/utils.js

@@ -1,14 +1,24 @@
-import { isRuntimeFunction, isRuntimeObject, isLazyList, isRuntimeClass, isRuntimePredicate, } from "yukigo-ast";
-export function createStream(generator) {
-    return {
-        type: "LazyList",
-        generator,
-    };
-}
+import { BindCommand, RaiseCommand, StepCommand, } from "./components/kernel/commands.js";
+import { YuNumber, LazyList, YuBoolean } from "./primitives/index.js";
+import { InterpreterError } from "./errors.js";
+export const raise = (err) => new RaiseCommand(err);
+export const error = (ctx, msg) => new InterpreterError(ctx, msg);
+export const boolean = (condition) => new StepCommand(new YuBoolean(condition));
+export const number = (num) => {
+    const rounded = Math.round(num * 100000) / 100000;
+    return new StepCommand(new YuNumber(rounded));
+};
+export const not = (command) => new BindCommand(command, (res) => res.asLogic?.not() || boolean(false));
+export const isTrue = (val) => val instanceof YuBoolean && val.value;
+export const compareResult = (command, predicate) => new BindCommand(command, (res) => boolean(predicate(res.toJSON())));
 export function isArrayOfNumbers(arr) {
-    for (const item of arr)
-        if (typeof item !== "number")
+    const seq = arr.asSequence;
+    if (!seq)
+        return false;
+    for (const item of seq) {
+        if (!item.asNumeric)
             return false;
+    }
     return true;
 }
 export function generateRange(start, end, step) {
@@ -18,13 +28,13 @@ export function generateRange(start, end, step) {
     let current = start;
     if (step > 0) {
         while (current <= end) {
-            result.push(current);
+            result.push(new YuNumber(current));
             current += step;
         }
     }
     else {
         while (current >= end) {
-            result.push(current);
+            result.push(new YuNumber(current));
             current += step;
         }
     }
@@ -43,23 +53,8 @@ export function createGlobalEnv() {
     };
 }
 export function getYukigoType(val) {
-    if (val === null || val === undefined)
-        return "YuNil";
-    if (typeof val === "number")
-        return "YuNumber";
-    if (typeof val === "boolean")
-        return "YuBoolean";
-    if (typeof val === "string")
-        return val.length === 1 ? "YuChar" : "YuString";
-    if (Array.isArray(val) || isLazyList(val))
-        return "YuList";
-    if (isRuntimeFunction(val))
-        return "YuFunction";
-    if (isRuntimeObject(val))
-        return "YuObject";
-    if (isRuntimeClass(val))
-        return "YuClass";
-    if (isRuntimePredicate(val))
-        return "YuPredicate";
-    return "YuUnknown";
+    return val.getType();
+}
+export function createStream(generator) {
+    return new LazyList(() => generator());
 }

package/dist/tester/index.d.ts

@@ -1,5 +1,5 @@
 import { AST } from "yukigo-ast";
-import { InterpreterConfig } from "../interpreter/components/RuntimeContext.js";
+import { InterpreterConfig } from "../utils/helpers.js";
 export type TestStatus = "passed" | "failed" | "error";
 export interface TestReport {
     name: string;
@@ -14,8 +14,8 @@ export interface TestReport {
  */
 export declare class Tester {
     private ast;
-    private config?;
-    constructor(ast: AST, config?: InterpreterConfig);
+    private config;
+    constructor(ast: AST, config?: Partial<InterpreterConfig>);
     /**
      * Executes all Test and TestGroup nodes found at the top level of the provided AST.
      * @param nodes The AST (or subset of nodes) to scan for tests.

package/dist/tester/index.js

@@ -1,19 +1,36 @@
 import { Test, TestGroup, TraverseVisitor, } from "yukigo-ast";
 import { Interpreter } from "../interpreter/index.js";
 import { FailedAssert } from "../interpreter/components/TestRunner.js";
+import { DefaultConfiguration, } from "../interpreter/components/RuntimeContext.js";
+import { UnexpectedNode } from "../interpreter/errors.js";
 class TestExecutor extends TraverseVisitor {
-    interpreter;
+    ast;
+    config;
+    parentGroupStatements;
     report = null;
-    constructor(interpreter) {
+    constructor(ast, config, parentGroupStatements = []) {
         super();
-        this.interpreter = interpreter;
+        this.ast = ast;
+        this.config = config;
+        this.parentGroupStatements = parentGroupStatements;
     }
     visitTest(node) {
-        const name = this.evaluateName(node.name);
+        const interpreter = new Interpreter(this.ast, this.config);
+        for (const stmt of this.parentGroupStatements) {
+            if (!(stmt instanceof Test) && !(stmt instanceof TestGroup)) {
+                interpreter.evaluate(stmt);
+            }
+        }
+        const name = this.evaluateName(interpreter, node.name);
         const start = Date.now();
         try {
-            //this.bindParameters(node);
-            this.interpreter.evaluate(node);
+            interpreter
+                .getContext()
+                .dispatchHook("beforeEachTest", interpreter, node);
+            interpreter.evaluate(node);
+            interpreter
+                .getContext()
+                .dispatchHook("afterEachTest", interpreter, node);
             this.report = {
                 name,
                 status: "passed",
@@ -24,30 +41,20 @@ class TestExecutor extends TraverseVisitor {
             this.report = this.handleError(name, start, error);
         }
     }
-    /*   private bindParameters(node: Test): void {
-      if (!node.args || node.args.length === 0) return;
-  
-      for (const pattern of node.args) {
-        if (pattern instanceof VariablePattern) {
-          this.interpreter.define(pattern.name.value, null);
-        }
-      }
-    } */
     visitTestGroup(node) {
-        const name = this.evaluateName(node.name);
+        const interpreter = new Interpreter(this.ast, this.config);
+        const name = this.evaluateName(interpreter, node.name);
         const start = Date.now();
         try {
             const children = [];
+            const nonTestStmts = node.group.statements.filter((stmt) => !(stmt instanceof Test) && !(stmt instanceof TestGroup));
             for (const stmt of node.group.statements) {
                 if (stmt instanceof Test || stmt instanceof TestGroup) {
-                    const visitor = new TestExecutor(this.interpreter);
+                    const visitor = new TestExecutor(this.ast, this.config, [...this.parentGroupStatements, ...nonTestStmts]);
                     stmt.accept(visitor);
                     if (visitor.report)
                         children.push(visitor.report);
                 }
-                else {
-                    this.interpreter.evaluate(stmt);
-                }
             }
             const anyFailed = children.some((c) => c.status !== "passed");
             this.report = {
@@ -61,9 +68,9 @@ class TestExecutor extends TraverseVisitor {
             this.report = this.handleError(name, start, error);
         }
     }
-    evaluateName(nameExpr) {
+    evaluateName(interpreter, nameExpr) {
         try {
-            return String(this.interpreter.evaluate(nameExpr));
+            return String(interpreter.evaluate(nameExpr));
         }
         catch {
             return "Unknown Test";
@@ -73,9 +80,13 @@ class TestExecutor extends TraverseVisitor {
         const duration = Date.now() - start;
         if (error instanceof FailedAssert)
             return { name, status: "failed", message: error.message, duration };
+        console.error(error);
         const message = error instanceof Error ? error.message : String(error);
         return { name, status: "error", message, duration };
     }
+    fallback(node) {
+        throw new UnexpectedNode(node.constructor.name, "TestExecutor");
+    }
 }
 /**
  * The Tester class provides a high-level API for executing test nodes
@@ -84,7 +95,7 @@ class TestExecutor extends TraverseVisitor {
 export class Tester {
     ast;
     config;
-    constructor(ast, config) {
+    constructor(ast, config = DefaultConfiguration) {
         this.ast = ast;
         this.config = config;
     }
@@ -96,12 +107,12 @@ export class Tester {
     test(nodes) {
         const reports = [];
         for (const node of nodes) {
-            if (node instanceof Test || node instanceof TestGroup) {
-                const interpreter = new Interpreter(this.ast, this.config);
-                const visitor = new TestExecutor(interpreter);
-                node.accept(visitor);
+            if (!node.is(Test) && !node.is(TestGroup))
+                continue;
+            const visitor = new TestExecutor(this.ast, this.config);
+            node.accept(visitor);
+            if (visitor.report)
                 reports.push(visitor.report);
-            }
         }
         return reports;
     }

package/dist/utils/helpers.d.ts

@@ -1,14 +1,21 @@
 import { InspectionRule } from "../analyzer/index.js";
+import { NativeExtension } from "../interpreter/utils.js";
+import { YukigoHook } from "../interpreter/components/hooks/YukigoHook.js";
+export type LogicSearchMode = "first" | "all" | "stream";
+export interface InterpreterConfig {
+    nativeProviders: Map<string, NativeExtension>;
+    lazyLoading: boolean;
+    debug: boolean;
+    outputMode: LogicSearchMode;
+    mutability: boolean;
+    hooks?: YukigoHook[];
+}
 /**
  * Translates Mulang inspections (YAML format) to an array of `InspectionRule` objects.
  * @param mulangYamlString The Mulang inspection syntax as a YAML string.
  * @returns An array of InspectionRule objects.
  */
 export declare class MulangAdapter {
-    translateMulangInspection(mulangInspection: unknown): InspectionRule;
+    translateMulangInspection(mulangInspection: any): InspectionRule;
     translateMulangExpectations(mulangYamlString: string): InspectionRule[];
-    private transformToV2;
-    private parseNegation;
-    private applyV0ToV2;
-    private retrieveArguments;
 }