yukigo 0.1.0 → 0.2.0

package/dist/interpreter/entities.d.ts

@@ -0,0 +1,105 @@
+import { Fact, Rule, Pattern, GuardedBody, UnguardedBody } from "yukigo-ast";
+export type SuccessLogicResult = {
+    success: true;
+    solutions: Map<string, PrimitiveValue>;
+};
+export type FailedLogicResult = {
+    success: false;
+};
+export type LogicResult = SuccessLogicResult | FailedLogicResult;
+export type PrimitiveValue = number | boolean | string | RuntimeFunction | RuntimePredicate | LogicResult | LazyList | null | void | PrimitiveValue[] | RuntimeObject | RuntimeClass | undefined;
+export declare function isLogicResult(value: PrimitiveValue): value is LogicResult;
+export type PrimitiveThunk = () => PrimitiveValue;
+export type Environment = Map<string, PrimitiveValue>;
+export type EnvStack = {
+    head: Environment;
+    tail: EnvStack | null;
+};
+type RuntimePredicateKind = "Fact" | "Rule" | "Predicate";
+type PredicateEquation = Fact | Rule;
+export interface IRuntimePredicate {
+    kind: RuntimePredicateKind;
+    identifier: string;
+    equations: PredicateEquation[];
+}
+export declare class RuntimePredicate implements IRuntimePredicate {
+    kind: RuntimePredicateKind;
+    identifier: string;
+    equations: PredicateEquation[];
+    constructor(kind: RuntimePredicateKind, identifier: string, equations: PredicateEquation[]);
+    pushEquation<T extends Fact | Rule>(eq: T): void;
+}
+export declare const isRuntimePredicate: (prim: PrimitiveValue) => prim is RuntimePredicate;
+type Body = GuardedBody[] | UnguardedBody;
+export interface IRuntimeEquation {
+    patterns: Pattern[];
+    body: Body;
+}
+export declare class RuntimeEquation implements IRuntimeEquation {
+    patterns: Pattern[];
+    body: Body;
+    constructor(patterns: Pattern[], body: Body);
+}
+type PendingArg = PrimitiveValue | PrimitiveThunk;
+/**
+ * Runtime Function used in the Interpreter
+ */
+export interface IRuntimeFunction {
+    arity: number;
+    identifier: string;
+    equations: RuntimeEquation[];
+    pendingArgs: PendingArg[];
+    closure?: EnvStack;
+}
+export declare class RuntimeFunction implements IRuntimeFunction {
+    arity: number;
+    identifier: string;
+    equations: RuntimeEquation[];
+    pendingArgs: PendingArg[];
+    closure?: EnvStack;
+    constructor(arity: number, identifier: string, equations: RuntimeEquation[], pendingArgs: PendingArg[], closure?: EnvStack);
+    setPendingArgs(args: PendingArg[]): void;
+}
+export declare function isRuntimeFunction(val: PrimitiveValue): val is RuntimeFunction;
+type Fields = Map<string, PrimitiveValue>;
+type Methods = Map<string, RuntimeFunction>;
+export interface IRuntimeClass {
+    identifier: string;
+    fields: Fields;
+    methods: Methods;
+    mixins: string[];
+    superclass?: string;
+}
+export declare class RuntimeClass implements IRuntimeClass {
+    identifier: string;
+    fields: Fields;
+    methods: Methods;
+    mixins: string[];
+    superclass?: string;
+    constructor(identifier: string, fields: Fields, methods: Methods, mixins: string[], superclass?: string);
+}
+export declare function isRuntimeClass(val: PrimitiveValue): val is RuntimeClass;
+export interface IRuntimeObject {
+    identifier: string;
+    className: string;
+    fields: Map<string, PrimitiveValue>;
+    methods: Map<string, RuntimeFunction>;
+}
+export declare class RuntimeObject implements IRuntimeObject {
+    identifier: string;
+    className: string;
+    fields: Fields;
+    methods: Methods;
+    constructor(identifier: string, className: string, fields: Fields, methods: Methods);
+}
+export declare function isRuntimeObject(val: PrimitiveValue): val is RuntimeObject;
+export type LazyGenerator = () => Generator<PrimitiveValue, void, unknown>;
+export interface ILazyList {
+    readonly generator: LazyGenerator;
+}
+export declare class LazyList implements ILazyList {
+    readonly generator: LazyGenerator;
+    constructor(generator: LazyGenerator);
+}
+export declare function isLazyList(prim: unknown): prim is LazyList;
+export {};

package/dist/interpreter/entities.js

@@ -0,0 +1,96 @@
+export function isLogicResult(value) {
+    return (value &&
+        typeof value === "object" &&
+        "success" in value &&
+        typeof value.success === "boolean" &&
+        "solutions" in value &&
+        value.solutions instanceof Map);
+}
+export class RuntimePredicate {
+    kind;
+    identifier;
+    equations;
+    constructor(kind, identifier, equations) {
+        this.kind = kind;
+        this.identifier = identifier;
+        this.equations = equations;
+    }
+    pushEquation(eq) {
+        this.equations.push(eq);
+    }
+}
+// TODO: Replace with correct polymorphism
+export const isRuntimePredicate = (prim) => {
+    return prim instanceof RuntimePredicate;
+};
+export class RuntimeEquation {
+    patterns;
+    body;
+    constructor(patterns, body) {
+        this.patterns = patterns;
+        this.body = body;
+    }
+}
+export class RuntimeFunction {
+    arity;
+    identifier;
+    equations;
+    pendingArgs;
+    closure;
+    constructor(arity, identifier, equations, pendingArgs, closure) {
+        this.arity = arity;
+        this.identifier = identifier;
+        this.equations = equations;
+        this.pendingArgs = pendingArgs;
+        this.closure = closure;
+    }
+    setPendingArgs(args) {
+        this.pendingArgs = args;
+    }
+}
+// TODO: Replace with correct polymorphism
+export function isRuntimeFunction(val) {
+    return val instanceof RuntimeFunction;
+}
+export class RuntimeClass {
+    identifier;
+    fields;
+    methods;
+    mixins;
+    superclass;
+    constructor(identifier, fields, methods, mixins, superclass) {
+        this.identifier = identifier;
+        this.fields = fields;
+        this.methods = methods;
+        this.mixins = mixins;
+        this.superclass = superclass;
+    }
+}
+// TODO: prev as before
+export function isRuntimeClass(val) {
+    return val instanceof RuntimeClass;
+}
+export class RuntimeObject {
+    identifier;
+    className;
+    fields;
+    methods;
+    constructor(identifier, className, fields, methods) {
+        this.identifier = identifier;
+        this.className = className;
+        this.fields = fields;
+        this.methods = methods;
+    }
+}
+export function isRuntimeObject(val) {
+    return val instanceof RuntimeObject;
+}
+export class LazyList {
+    generator;
+    constructor(generator) {
+        this.generator = generator;
+    }
+}
+export function isLazyList(prim) {
+    return prim instanceof LazyList;
+}

package/dist/interpreter/errors.d.ts

@@ -1,4 +1,4 @@
-import { SourceLocation } from "@yukigo/ast";
+import { SourceLocation } from "yukigo-ast";
 export interface ErrorFrame {
     nodeType: string;
     loc?: SourceLocation;

package/dist/interpreter/index.d.ts

@@ -1,13 +1,6 @@
-import { PrimitiveValue, Expression, AST } from "@yukigo/ast";
+import { PrimitiveValue, AST, ASTNode } from "yukigo-ast";
+import { InterpreterConfig } from "./components/RuntimeContext.js";
 export type Bindings = [string, PrimitiveValue][];
-export type LogicSearchMode = "first" | "all" | "stream";
-export type InterpreterConfig = {
-    lazyLoading?: boolean;
-    debug?: boolean;
-    outputMode?: LogicSearchMode;
-};
-export type Environment = Map<string, PrimitiveValue>;
-export type EnvStack = Environment[];
 /**
  * The Interpreter class is responsible for evaluating the Abstract Syntax Tree (AST)
  * generated by the parsers.
@@ -16,8 +9,7 @@ export type EnvStack = Environment[];
  * of Expression nodes to a dedicated visitor.
  */
 export declare class Interpreter {
-    private globalEnv;
-    private readonly config;
+    private context;
     /**
      * @param ast The Abstract Syntax Tree (AST) of the program to be interpreted.
      */
@@ -28,5 +20,5 @@ export declare class Interpreter {
      * @param expr The root Expression node to be evaluated.
      * @returns The resulting primitive value (number, string, boolean, etc.) after evaluation.
      */
-    evaluate(expr: Expression): PrimitiveValue;
+    evaluate(expr: ASTNode): PrimitiveValue;
 }

package/dist/interpreter/index.js

@@ -1,11 +1,8 @@
 import { InterpreterVisitor } from "./components/Visitor.js";
 import { EnvBuilderVisitor } from "./components/EnvBuilder.js";
 import { InterpreterError } from "./errors.js";
-const DefaultConfiguration = {
-    lazyLoading: false,
-    debug: false,
-    outputMode: "first",
-};
+import { idContinuation, trampoline } from "./trampoline.js";
+import { RuntimeContext, } from "./components/RuntimeContext.js";
 /**
  * The Interpreter class is responsible for evaluating the Abstract Syntax Tree (AST)
  * generated by the parsers.
@@ -14,14 +11,14 @@ const DefaultConfiguration = {
  * of Expression nodes to a dedicated visitor.
  */
 export class Interpreter {
-    globalEnv;
-    config;
+    context;
     /**
      * @param ast The Abstract Syntax Tree (AST) of the program to be interpreted.
      */
-    constructor(ast, config) {
-        this.globalEnv = new EnvBuilderVisitor().build(ast);
-        this.config = config ?? DefaultConfiguration;
+    constructor(ast, config = {}) {
+        this.context = new RuntimeContext(config);
+        const builder = new EnvBuilderVisitor(this.context);
+        builder.build(ast);
     }
     /**
      * Evaluates a single Expression node within the context of the global environment.
@@ -31,9 +28,9 @@ export class Interpreter {
      */
     evaluate(expr) {
         try {
-            const visitor = new InterpreterVisitor(this.globalEnv, this.config);
-            const evaluatedExpr = expr.accept(visitor);
-            return evaluatedExpr;
+            const visitor = new InterpreterVisitor(this.context);
+            const evaluatedCPS = expr.accept(visitor);
+            return trampoline(evaluatedCPS(idContinuation));
         }
         catch (error) {
             if (error instanceof InterpreterError)

package/dist/interpreter/trampoline.d.ts

@@ -0,0 +1,17 @@
+import { PrimitiveValue } from "yukigo-ast";
+export type CallableThunk<T> = () => Thunk<T>;
+export type Thunk<T> = T | CallableThunk<T>;
+export type Continuation<T, R = any> = (value: T) => Thunk<R>;
+export declare const idContinuation: Continuation<PrimitiveValue>;
+export declare function trampoline<T>(thunk: Thunk<T>): T;
+/**
+ * A specialized Thunk type for our CPS visitor.
+ * This is a function that, when called, takes the continuation for the current node's evaluation
+ * and returns the actual Thunk chain for that node.
+ * This effectively injects the continuation *after* the `visit` method has returned.
+ */
+export type CPSThunk<T, R = any> = (k: Continuation<T, R>) => Thunk<R>;
+export declare function makeCPSThunk<T>(fn: (k: Continuation<T>) => Thunk<T>): CPSThunk<T>;
+export declare function bindCPS<A, B, R>(cpsA: CPSThunk<A, R>, f: (valueA: A) => CPSThunk<B, R>): CPSThunk<B, R>;
+export declare function valueToCPS<T, R>(value: T): CPSThunk<T, R>;
+export declare function thunkToCPS<T>(thunk: Thunk<T>): CPSThunk<T>;

package/dist/interpreter/trampoline.js

@@ -0,0 +1,38 @@
+const isCallableThunk = (thunk) => typeof thunk === "function";
+// The identity continuation: simply returns the value as a resolved Thunk.
+// This is used for the very last step of a computation or when a value is final.
+export const idContinuation = (value) => value;
+// The trampoline function executes a chain of Thunks until a final non-function value is reached.
+export function trampoline(thunk) {
+    let result = thunk;
+    while (isCallableThunk(result))
+        result = result();
+    return result;
+}
+// Helper to create a CPSThunk for visitor methods.
+// Visitor methods will call this, providing a function that knows how to use 'k'.
+export function makeCPSThunk(fn) {
+    return fn;
+}
+// Helper to compose asynchronous/CPS operations.
+// `cpsA` is a CPSThunk that eventually produces a value A.
+// `f` is a function that takes A and returns a CPSThunk that eventually produces B.
+export function bindCPS(cpsA, f) {
+    return (k) => {
+        return () => cpsA((valueA) => {
+            // f(valueA) returns a CPSThunk<B, R>
+            // calling that with 'k' returns Thunk<R>
+            return f(valueA)(k);
+        });
+    };
+}
+// Helper to lift a direct value into a CPSThunk
+export function valueToCPS(value) {
+    return (k) => () => k(value);
+}
+// Helper to lift a regular Thunk into a CPSThunk (if it resolves a simple Thunk)
+export function thunkToCPS(thunk) {
+    return (k) => {
+        return () => k(trampoline(thunk)); // Trampoline the simple thunk and pass its result to k
+    };
+}

package/dist/interpreter/utils.d.ts

@@ -1,14 +1,11 @@
-import { Expression, LazyList, PrimitiveValue } from "@yukigo/ast";
-import { Environment, EnvStack } from "./index.js";
+import { LazyList, PrimitiveValue, Environment, EnvStack, ASTNode } from "yukigo-ast";
+import { Continuation, Thunk } from "./trampoline.js";
 export interface ExpressionEvaluator {
-    evaluate(node: Expression): PrimitiveValue;
+    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;
 export declare function createGlobalEnv(): EnvStack;
-export declare function pushEnv(env: EnvStack, frame?: Environment): EnvStack;
-export declare function popEnv(env: EnvStack): EnvStack;
-export declare function lookup(env: EnvStack, name: string): PrimitiveValue;
-export declare function define(env: EnvStack, name: string, value: PrimitiveValue): void;
+export declare function getYukigoType(val: PrimitiveValue): string;

package/dist/interpreter/utils.js

@@ -1,4 +1,4 @@
-import { UnboundVariable } from "./errors.js";
+import { isRuntimeFunction, isRuntimeObject, isLazyList, isRuntimeClass, isRuntimePredicate, } from "yukigo-ast";
 export function createStream(generator) {
     return {
         type: "LazyList",
@@ -37,21 +37,29 @@ export function createEnv(bindings) {
     return env;
 }
 export function createGlobalEnv() {
-    return [new Map()];
-}
-export function pushEnv(env, frame) {
-    return [frame ?? new Map(), ...env];
-}
-export function popEnv(env) {
-    return env.slice(1);
-}
-export function lookup(env, name) {
-    for (const frame of env) {
-        if (frame.has(name))
-            return frame.get(name);
-    }
-    throw new UnboundVariable(name);
+    return {
+        head: new Map(),
+        tail: null,
+    };
 }
-export function define(env, name, value) {
-    env[0].set(name, value);
+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";
 }

package/dist/tester/index.d.ts

@@ -0,0 +1,25 @@
+import { AST } from "yukigo-ast";
+import { InterpreterConfig } from "../interpreter/components/RuntimeContext.js";
+export type TestStatus = "passed" | "failed" | "error";
+export interface TestReport {
+    name: string;
+    status: TestStatus;
+    message?: string;
+    duration?: number;
+    children?: TestReport[];
+}
+/**
+ * The Tester class provides a high-level API for executing test nodes
+ * (Tests and TestGroups) within an AST and generating a detailed report.
+ */
+export declare class Tester {
+    private ast;
+    private config?;
+    constructor(ast: AST, config?: 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.
+     * @returns An array of TestReport objects for each top-level test/group.
+     */
+    test(nodes: AST): TestReport[];
+}

package/dist/tester/index.js

@@ -0,0 +1,108 @@
+import { Test, TestGroup, TraverseVisitor, } from "yukigo-ast";
+import { Interpreter } from "../interpreter/index.js";
+import { FailedAssert } from "../interpreter/components/TestRunner.js";
+class TestExecutor extends TraverseVisitor {
+    interpreter;
+    report = null;
+    constructor(interpreter) {
+        super();
+        this.interpreter = interpreter;
+    }
+    visitTest(node) {
+        const name = this.evaluateName(node.name);
+        const start = Date.now();
+        try {
+            //this.bindParameters(node);
+            this.interpreter.evaluate(node);
+            this.report = {
+                name,
+                status: "passed",
+                duration: Date.now() - start,
+            };
+        }
+        catch (error) {
+            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 start = Date.now();
+        try {
+            const children = [];
+            for (const stmt of node.group.statements) {
+                if (stmt instanceof Test || stmt instanceof TestGroup) {
+                    const visitor = new TestExecutor(this.interpreter);
+                    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 = {
+                name,
+                status: anyFailed ? "failed" : "passed",
+                duration: Date.now() - start,
+                children,
+            };
+        }
+        catch (error) {
+            this.report = this.handleError(name, start, error);
+        }
+    }
+    evaluateName(nameExpr) {
+        try {
+            return String(this.interpreter.evaluate(nameExpr));
+        }
+        catch {
+            return "Unknown Test";
+        }
+    }
+    handleError(name, start, error) {
+        const duration = Date.now() - start;
+        if (error instanceof FailedAssert)
+            return { name, status: "failed", message: error.message, duration };
+        const message = error instanceof Error ? error.message : String(error);
+        return { name, status: "error", message, duration };
+    }
+}
+/**
+ * The Tester class provides a high-level API for executing test nodes
+ * (Tests and TestGroups) within an AST and generating a detailed report.
+ */
+export class Tester {
+    ast;
+    config;
+    constructor(ast, config) {
+        this.ast = ast;
+        this.config = config;
+    }
+    /**
+     * 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.
+     * @returns An array of TestReport objects for each top-level test/group.
+     */
+    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);
+                reports.push(visitor.report);
+            }
+        }
+        return reports;
+    }
+}

package/dist/utils/helpers.d.ts

@@ -1,5 +1,4 @@
 import { InspectionRule } from "../analyzer/index.js";
-import { YukigoPrimitive } from "@yukigo/ast";
 /**
  * Translates Mulang inspections (YAML format) to an array of `InspectionRule` objects.
  * @param mulangYamlString The Mulang inspection syntax as a YAML string.
@@ -9,6 +8,3 @@ export declare class MulangAdapter {
     translateMulangInspection(mulangInspection: any): InspectionRule;
     translateMulangExpectations(mulangYamlString: string): InspectionRule[];
 }
-export declare const yukigoTsMappings: {
-    [key in YukigoPrimitive]: string;
-};

package/dist/utils/helpers.js

@@ -1,4 +1,7 @@
 import { parseDocument } from "yaml";
+const isValidFormat = (inspection) => typeof inspection === "object" &&
+    "inspection" in inspection &&
+    "binding" in inspection;
 /**
  * Translates Mulang inspections (YAML format) to an array of `InspectionRule` objects.
  * @param mulangYamlString The Mulang inspection syntax as a YAML string.
@@ -6,13 +9,10 @@ import { parseDocument } from "yaml";
  */
 export class MulangAdapter {
     translateMulangInspection(mulangInspection) {
-        if (!mulangInspection ||
-            typeof mulangInspection.inspection !== "string" ||
-            typeof mulangInspection.binding !== "string") {
-            throw Error(`Skipping malformed Mulang inspection entry: ${mulangInspection}`);
-        }
+        if (!isValidFormat(mulangInspection))
+            throw new Error(`Skipping malformed Mulang inspection entry: ${mulangInspection}`);
         const inspection = mulangInspection.inspection.split(":");
-        const expected = inspection[0] !== "Not";
+        const expected = inspection[0] !== "Not" && inspection[0] !== "Except";
         const args = inspection.slice(expected ? 1 : 2);
         return {
             inspection: expected ? inspection[0] : inspection[1],
@@ -22,30 +22,26 @@ export class MulangAdapter {
         };
     }
     translateMulangExpectations(mulangYamlString) {
+        if (!mulangYamlString)
+            return [];
         const parsedYaml = parseDocument(mulangYamlString).toJS();
-        if (!parsedYaml ||
-            !parsedYaml.expectations ||
-            !Array.isArray(parsedYaml.expectations)) {
-            throw Error("Invalid Mulang YAML structure. Expected 'expectations' to be an array.");
+        if (!parsedYaml)
+            return [];
+        let expectations = [];
+        if (Array.isArray(parsedYaml)) {
+            expectations = parsedYaml;
+        }
+        else if (Array.isArray(parsedYaml.expectations)) {
+            expectations = parsedYaml.expectations;
+        }
+        else {
+            throw new Error("Invalid Mulang YAML structure. Expected 'expectations' to be an array.");
         }
         const inspectionRules = [];
-        for (const mulangInspection of parsedYaml.expectations) {
+        for (const mulangInspection of expectations) {
             const inspection = this.translateMulangInspection(mulangInspection);
             inspectionRules.push(inspection);
         }
         return inspectionRules;
     }
 }
-export const yukigoTsMappings = {
-    YuNumber: "number",
-    YuString: "string",
-    YuChar: "char",
-    YuBoolean: "boolean",
-    YuNil: "null",
-    // Below some missing mappigs
-    YuList: "YuList",
-    YuObject: "YuObject",
-    YuDict: "YuDict",
-    YuTuple: "YuTuple",
-    YuSymbol: "YuSymbol",
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yukigo",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,7 +15,7 @@
   "dependencies": {
     "typescript": "^5.9.2",
     "yaml": "^2.8.0",
-    "yukigo-ast": "0.1.0"
+    "yukigo-ast": "^0.2.0"
   },
   "devDependencies": {
     "@types/chai": "^5.2.2",