yukigo 0.1.0 → 0.2.0

package/dist/analyzer/utils.js

@@ -1,16 +1,74 @@
-import { StopTraversalException } from "@yukigo/ast";
-export function executeVisitor(node, visitor) {
-    let passes = false;
-    try {
-        node.accept(visitor);
-    }
-    catch (e) {
-        if (e instanceof StopTraversalException) {
-            passes = true;
-        }
-        else {
-            throw e;
+import { TraverseVisitor, } from "yukigo-ast";
+export class ScopedVisitor extends TraverseVisitor {
+    binding;
+    inScope;
+    constructor(binding) {
+        super();
+        this.setBinding(binding);
+    }
+    setBinding(binding) {
+        this.binding = binding;
+        this.inScope = !binding;
+    }
+    visitVariable(node) {
+        this.manageScope(node, () => super.visitVariable(node));
+    }
+    visitFunction(node) {
+        this.manageScope(node, () => super.visitFunction(node));
+    }
+    visitClass(node) {
+        this.manageScope(node, () => super.visitClass(node));
+    }
+    visitObject(node) {
+        this.manageScope(node, () => super.visitObject(node));
+    }
+    visitMethod(node) {
+        this.manageScope(node, () => super.visitMethod(node));
+    }
+    visitRule(node) {
+        this.manageScope(node, () => super.visitRule(node));
+    }
+    visitFact(node) {
+        this.manageScope(node, () => super.visitFact(node));
+    }
+    visitProcedure(node) {
+        this.manageScope(node, () => super.visitProcedure(node));
+    }
+    manageScope(node, traverse) {
+        const isTarget = node.identifier.value === this.binding;
+        if (isTarget)
+            this.inScope = true;
+        traverse();
+        if (isTarget)
+            this.inScope = false;
+    }
+}
+export function AutoScoped(constructor) {
+    const proto = constructor.prototype;
+    const methodNames = Object.getOwnPropertyNames(proto);
+    for (const name of methodNames) {
+        if (isValidVisitMethod(name)) {
+            const originalMethod = proto[name];
+            // replace the method on the prototype
+            proto[name] = function (node) {
+                if (!this.inScope)
+                    return;
+                // run the inspection logic if in scope
+                return originalMethod.call(this, node);
+            };
         }
     }
-    return passes;
 }
+function isScopeBoundary(name) {
+    return [
+        "visitFunction",
+        "visitMethod",
+        "visitProcedure",
+        "visitRule",
+        "visitFact",
+        "visitVariable",
+        "visitClass",
+        "visitObject",
+    ].includes(name);
+}
+const isValidVisitMethod = (name) => name.startsWith("visit") && name !== "constructor" && !isScopeBoundary(name);

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./interpreter/index.js";
 export * from "./analyzer/index.js";
+export * from "./tester/index.js";
 export * from "./utils/helpers.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from "./interpreter/index.js";
 export * from "./analyzer/index.js";
+export * from "./tester/index.js";
 export * from "./utils/helpers.js";

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

@@ -1,16 +1,20 @@
-import { AST, ASTNode, Fact, Function, Rule, TraverseVisitor } from "@yukigo/ast";
-import { EnvStack } from "../index.js";
+import { AST, ASTNode, Class, Fact, Function, Rule, TraverseVisitor, Object, Variable, Sequence } from "yukigo-ast";
+import { RuntimeContext } from "./RuntimeContext.js";
 /**
  * Builds the initial environment by collecting all top-level function declarations.
  * Each function captures a closure of the environment at its definition time,
  * allowing recursion by including itself in the closure.
  */
 export declare class EnvBuilderVisitor extends TraverseVisitor {
-    private env;
-    constructor(baseEnv?: EnvStack);
-    build(ast: AST): EnvStack;
+    private ctx;
+    constructor(ctx: RuntimeContext);
+    build(ast: AST): void;
+    visitSequence(node: Sequence): void;
     visitFunction(node: Function): void;
+    visitClass(node: Class): void;
+    visitObject(node: Object): void;
     visitFact(node: Fact): void;
     visitRule(node: Rule): void;
+    visitVariable(node: Variable): void;
     visit(node: ASTNode): void;
 }

package/dist/interpreter/components/EnvBuilder.js

@@ -1,55 +1,100 @@
-import { isRuntimePredicate, TraverseVisitor, } from "@yukigo/ast";
-import { define } from "../utils.js";
+import { isRuntimePredicate, TraverseVisitor, } from "yukigo-ast";
+import { InterpreterVisitor } from "./Visitor.js";
+import { idContinuation, trampoline } from "../trampoline.js";
+import { InterpreterError } from "../errors.js";
 /**
  * Builds the initial environment by collecting all top-level function declarations.
  * Each function captures a closure of the environment at its definition time,
  * allowing recursion by including itself in the closure.
  */
 export class EnvBuilderVisitor extends TraverseVisitor {
-    env;
-    constructor(baseEnv) {
+    ctx;
+    constructor(ctx) {
         super();
-        this.env = baseEnv ?? [new Map()];
+        this.ctx = ctx;
     }
     build(ast) {
         for (const node of ast)
             node.accept(this);
-        return this.env;
+    }
+    visitSequence(node) {
+        for (const stmt of node.statements)
+            stmt.accept(this);
     }
     visitFunction(node) {
         const name = node.identifier.value;
+        if (this.ctx.config.debug)
+            console.log(`[EnvBuilder] Defining function: ${name}`);
         if (node.equations.length === 0)
             throw new Error(`Function ${name} has no equations`);
         const arity = node.equations[0].patterns.length;
-        for (const eq of node.equations) {
-            if (eq.patterns.length !== arity)
-                throw new Error(`All equations of ${name} must have the same arity`);
-        }
+        if (node.equations.some((eq) => eq.patterns.length !== arity))
+            throw new Error(`All equations of ${name} must have the same arity`);
         let placeholder;
-        define(this.env, name, placeholder);
+        this.ctx.define(name, placeholder);
         const equations = node.equations.map((eq) => ({
             patterns: eq.patterns,
             body: eq.body,
         }));
         const runtimeFunc = {
+            type: "Function",
             identifier: name,
             arity,
             equations,
+            closure: this.ctx.env,
+        };
+        this.ctx.define(name, runtimeFunc);
+    }
+    visitClass(node) {
+        const identifier = node.identifier.value;
+        if (this.ctx.config.debug)
+            console.log(`[EnvBuilder] Defining class: ${identifier}`);
+        const superclass = node.extendsSymbol?.value;
+        const mixins = node.includes.map((symbol) => symbol.value);
+        const collector = new OOPCollector();
+        node.expression.accept(collector);
+        const fields = collector.collectedFields;
+        const methods = collector.collectedMethods;
+        const runtimeClass = {
+            type: "Class",
+            identifier,
+            fields,
+            methods,
+            superclass,
+            mixins,
+        };
+        this.ctx.define(identifier, runtimeClass);
+    }
+    visitObject(node) {
+        const identifier = node.identifier.value;
+        if (this.ctx.config.debug)
+            console.log(`[EnvBuilder] Defining object: ${identifier}`);
+        const collector = new OOPCollector();
+        node.expression.accept(collector);
+        const fields = collector.collectedFields;
+        const methods = collector.collectedMethods;
+        const runtimeObject = {
+            type: "Object",
+            identifier,
+            className: "",
+            fields,
+            methods,
         };
-        define(this.env, name, runtimeFunc);
+        this.ctx.define(identifier, runtimeObject);
     }
     visitFact(node) {
         const identifier = node.identifier.value;
-        const runtimeValue = this.env[0].get(identifier);
-        if (isRuntimePredicate(runtimeValue) && runtimeValue.kind === "Fact") {
-            this.env[0].set(identifier, {
-                ...runtimeValue,
-                equations: [...runtimeValue.equations, node],
-            });
+        if (this.ctx.config.debug)
+            console.log(`[EnvBuilder] Defining fact: ${identifier}`);
+        try {
+            const runtimeValue = this.ctx.lookup(identifier);
+            if (!isRuntimePredicate(runtimeValue))
+                throw new InterpreterError("EnvBuilder", `"${identifier}" is not a predicate. Maybe there is something else defined as "${identifier}"?`);
+            runtimeValue.equations.push(node);
         }
-        else {
-            this.env[0].set(identifier, {
-                kind: "Fact",
+        catch (error) {
+            this.ctx.define(identifier, {
+                kind: "Predicate",
                 identifier,
                 equations: [node],
             });
@@ -57,22 +102,47 @@ export class EnvBuilderVisitor extends TraverseVisitor {
     }
     visitRule(node) {
         const identifier = node.identifier.value;
-        const runtimeValue = this.env[0].get(identifier);
-        if (isRuntimePredicate(runtimeValue) && runtimeValue.kind === "Rule") {
-            this.env[0].set(identifier, {
-                ...runtimeValue,
-                equations: [...runtimeValue.equations, node],
-            });
+        if (this.ctx.config.debug)
+            console.log(`[EnvBuilder] Defining rule: ${identifier}`);
+        try {
+            const runtimeValue = this.ctx.lookup(identifier);
+            if (!isRuntimePredicate(runtimeValue))
+                throw new InterpreterError("EnvBuilder", `"${identifier}" is not a predicate. Maybe there is something else defined as "${identifier}"?`);
+            runtimeValue.equations.push(node);
         }
-        else {
-            this.env[0].set(identifier, {
-                kind: "Rule",
+        catch (error) {
+            this.ctx.define(identifier, {
+                kind: "Predicate",
                 identifier,
                 equations: [node],
             });
         }
     }
+    visitVariable(node) {
+        const identifier = node.identifier.value;
+        if (this.ctx.config.debug)
+            console.log(`[EnvBuilder] Defining variable: ${identifier}`);
+        const interpreter = new InterpreterVisitor(this.ctx);
+        const cps = node.expression.accept(interpreter);
+        this.ctx.define(identifier, trampoline(cps(idContinuation)));
+    }
     visit(node) {
         return node.accept(this);
     }
 }
+class OOPCollector extends TraverseVisitor {
+    collectedMethods = new Map();
+    collectedFields = new Map();
+    visitMethod(node) {
+        const runtimeMethod = {
+            type: "Function",
+            identifier: node.identifier.value,
+            arity: node.equations[0].patterns.length,
+            equations: node.equations,
+        };
+        this.collectedMethods.set(node.identifier.value, runtimeMethod);
+    }
+    visitAttribute(node) {
+        this.collectedFields.set(node.identifier.value, InterpreterVisitor.evaluateLiteral(node.expression));
+    }
+}

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

@@ -1,4 +1,4 @@
-import { PrimitiveValue } from "@yukigo/ast";
+import { PrimitiveValue } from "yukigo-ast";
 export type UnaryOp<T, R = T> = (x: T) => R;
 export type BinaryOp<T, R = T> = (x: T, y: T) => R;
 export type OperatorTable<T> = Record<string, T>;
@@ -6,9 +6,9 @@ export declare const ArithmeticBinaryTable: OperatorTable<BinaryOp<number>>;
 export declare const ComparisonOperationTable: OperatorTable<BinaryOp<boolean>>;
 export declare const LogicalBinaryTable: OperatorTable<(l: boolean, r: () => boolean) => boolean>;
 export declare const BitwiseBinaryTable: OperatorTable<BinaryOp<number>>;
-export declare const StringOperationTable: OperatorTable<BinaryOp<string>>;
+export declare const StringOperationTable: OperatorTable<BinaryOp<any, string>>;
 export declare const BitwiseUnaryTable: OperatorTable<UnaryOp<number>>;
 export declare const LogicalUnaryTable: OperatorTable<UnaryOp<boolean>>;
-export declare const ListBinaryTable: OperatorTable<BinaryOp<PrimitiveValue[]>>;
+export declare const ListBinaryTable: OperatorTable<BinaryOp<any, PrimitiveValue>>;
 export declare const ListUnaryTable: OperatorTable<UnaryOp<PrimitiveValue[], PrimitiveValue>>;
-export declare const ArithmeticUnaryTable: OperatorTable<UnaryOp<number>>;
+export declare const ArithmeticUnaryTable: OperatorTable<UnaryOp<number, number | string>>;

package/dist/interpreter/components/Operations.js

@@ -34,7 +34,13 @@ export const BitwiseBinaryTable = {
     BitwiseXor: (a, b) => a ^ b,
 };
 export const StringOperationTable = {
-    Concat: (a, b) => `${a + b}`,
+    Concat: (a, b) => {
+        if ((typeof a !== "string" && typeof a !== "number") ||
+            (typeof b !== "string" && typeof b !== "number")) {
+            throw new Error(`String Concatenation: operands must be strings or numbers, got ${typeof a} and ${typeof b}`);
+        }
+        return String(a) + String(b);
+    },
 };
 export const BitwiseUnaryTable = {
     BitwiseNot: (a) => ~a,
@@ -43,7 +49,15 @@ export const LogicalUnaryTable = {
     Negation: (a) => !a,
 };
 export const ListBinaryTable = {
-    Concat: (a, b) => a.concat(b),
+    Concat: (a, b) => {
+        const res = a.concat(b);
+        if (typeof a === "string" && typeof b === "string") {
+            const hasNonString = res.some((c) => typeof c !== "string");
+            if (!hasNonString)
+                return res.join("");
+        }
+        return res;
+    },
 };
 export const ListUnaryTable = {
     Size: (a) => a.length,
@@ -66,4 +80,5 @@ export const ArithmeticUnaryTable = {
     Floor: (a) => Math.floor(a),
     Negation: (a) => a * -1,
     Sqrt: (a) => Math.sqrt(a),
+    ToString: (a) => String(a),
 };

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

@@ -1,5 +1,33 @@
-import { ApplicationPattern, AsPattern, ASTNode, ConsPattern, ConstructorPattern, FunctorPattern, ListPattern, LiteralPattern, PrimitiveValue, TuplePattern, UnionPattern, VariablePattern, Visitor, WildcardPattern } from "@yukigo/ast";
+import { ApplicationPattern, AsPattern, ASTNode, ConsPattern, ConstructorPattern, Expression, FunctorPattern, LazyList, ListPattern, LiteralPattern, PrimitiveValue, TuplePattern, UnionPattern, VariablePattern, Visitor, WildcardPattern, TypePattern, EnvStack } from "yukigo-ast";
 import { Bindings } from "../index.js";
+import { CPSThunk } from "../trampoline.js";
+import { RuntimeContext } from "./RuntimeContext.js";
+import { ExpressionEvaluator } from "../utils.js";
+declare class SharedSequence {
+    private cache;
+    private source;
+    private isDone;
+    constructor(generatorFactory: () => Generator<PrimitiveValue, void, unknown>);
+    get(index: number): {
+        value: PrimitiveValue | null;
+        done: boolean;
+    };
+}
+export interface InternalConsState {
+    readonly head: PrimitiveValue;
+    readonly tailExpr: Expression;
+    readonly evaluator: ExpressionEvaluator;
+    readonly capturedEnv: EnvStack;
+    realizedTail?: PrimitiveValue;
+}
+export interface MemoizedLazyList extends LazyList {
+    _sequence: SharedSequence;
+    _offset: number;
+    _consState?: InternalConsState;
+    toJSON: () => any;
+}
+export declare function isMemoizedList(list: unknown): list is MemoizedLazyList;
+export declare function createMemoizedStream(genFactory: () => Generator<PrimitiveValue, void, unknown>, sequence?: SharedSequence, offset?: number): MemoizedLazyList;
 export declare class PatternResolver implements Visitor<string> {
     visitVariablePattern(node: VariablePattern): string;
     visitWildcardPattern(node: WildcardPattern): string;
@@ -11,6 +39,7 @@ export declare class PatternResolver implements Visitor<string> {
     visitFunctorPattern(node: FunctorPattern): string;
     visitApplicationPattern(node: ApplicationPattern): string;
     visitAsPattern(node: AsPattern): string;
+    visitTypePattern(node: TypePattern): string;
     visit(node: ASTNode): string;
 }
 /**
@@ -18,24 +47,25 @@ export declare class PatternResolver implements Visitor<string> {
  * Updates `bindings` when variables are bound successfully.
  * Returns true if the pattern matches, false otherwise.
  */
-export declare class PatternMatcher implements Visitor<boolean> {
+export declare class PatternMatcher implements Visitor<CPSThunk<boolean>> {
     private value;
     private bindings;
-    constructor(value: PrimitiveValue, bindings: Bindings);
-    visitVariablePattern(node: VariablePattern): boolean;
-    visitWildcardPattern(node: WildcardPattern): boolean;
-    visitLiteralPattern(node: LiteralPattern): boolean;
-    visitTuplePattern(node: TuplePattern): boolean;
-    visitListPattern(node: ListPattern): boolean;
+    private ctx;
+    constructor(value: PrimitiveValue, bindings: Bindings, ctx: RuntimeContext);
+    visitVariablePattern(node: VariablePattern): CPSThunk<boolean>;
+    visitWildcardPattern(node: WildcardPattern): CPSThunk<boolean>;
+    visitLiteralPattern(node: LiteralPattern): CPSThunk<boolean>;
+    visitTuplePattern(node: TuplePattern): CPSThunk<boolean>;
+    visitListPattern(node: ListPattern): CPSThunk<boolean>;
     private matchList;
-    visitConsPattern(node: ConsPattern): boolean;
+    visitConsPattern(node: ConsPattern): CPSThunk<boolean>;
+    visitTypePattern(node: TypePattern): CPSThunk<boolean>;
     private resolveCons;
-    visitConstructorPattern(node: ConstructorPattern): boolean;
-    visitFunctorPattern(node: FunctorPattern): boolean;
-    visitApplicationPattern(node: ApplicationPattern): boolean;
-    visitAsPattern(node: AsPattern): boolean;
-    visitUnionPattern(node: UnionPattern): boolean;
-    visit(node: ASTNode): boolean;
-    private deepEqual;
-    private realize;
+    visitConstructorPattern(node: ConstructorPattern): CPSThunk<boolean>;
+    visitFunctorPattern(node: FunctorPattern): CPSThunk<boolean>;
+    visitApplicationPattern(node: ApplicationPattern): CPSThunk<boolean>;
+    visitAsPattern(node: AsPattern): CPSThunk<boolean>;
+    visitUnionPattern(node: UnionPattern): CPSThunk<boolean>;
+    visit(node: ASTNode): CPSThunk<boolean>;
 }
+export {};