yukigo 0.2.0 → 0.2.2

package/dist/src/analyzer/utils.js

@@ -0,0 +1,78 @@
+import { TraverseVisitor, } from "yukigo-ast";
+export class InspectionVisitor extends TraverseVisitor {
+    fallback(node) { }
+}
+export class ScopedVisitor extends InspectionVisitor {
+    binding;
+    inScope = false;
+    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));
+    }
+    fallback(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);
+            };
+        }
+    }
+}
+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/src/index.d.ts

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

package/dist/src/index.js

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

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

@@ -0,0 +1,21 @@
+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 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;
+    fallback(node: ASTNode): string;
+}

package/dist/src/interpreter/components/EnvBuilder.js

@@ -0,0 +1,155 @@
+import { isRuntimePredicate, TraverseVisitor, } from "yukigo-ast";
+import { InterpreterVisitor } from "./Visitor.js";
+import { idContinuation, trampoline } from "../trampoline.js";
+import { InterpreterError } from "../errors.js";
+import { UnexpectedNode } from "../../utils/helpers.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 {
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    build(ast) {
+        for (const node of ast)
+            node.accept(this);
+    }
+    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;
+        if (node.equations.some((eq) => eq.patterns.length !== arity))
+            throw new Error(`All equations of ${name} must have the same arity`);
+        let placeholder = { type: "Function", arity: 0, equations: [] };
+        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,
+        };
+        this.ctx.define(identifier, runtimeObject);
+    }
+    visitFact(node) {
+        const identifier = node.identifier.value;
+        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);
+        }
+        catch (error) {
+            this.ctx.define(identifier, {
+                kind: "Predicate",
+                identifier,
+                equations: [node],
+            });
+        }
+    }
+    visitRule(node) {
+        const identifier = node.identifier.value;
+        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);
+        }
+        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);
+    }
+    fallback(node) {
+        throw new UnexpectedNode(node.constructor.name, "EnvBuilderVisitor");
+    }
+}
+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));
+    }
+    fallback(node) {
+        throw new UnexpectedNode(node.constructor.name, "OOPCollector");
+    }
+}

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

@@ -0,0 +1,14 @@
+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>;
+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<any, string>>;
+export declare const BitwiseUnaryTable: OperatorTable<UnaryOp<number>>;
+export declare const LogicalUnaryTable: OperatorTable<UnaryOp<boolean>>;
+export declare const ListBinaryTable: OperatorTable<BinaryOp<any, PrimitiveValue>>;
+export declare const ListUnaryTable: OperatorTable<UnaryOp<PrimitiveValue[], PrimitiveValue>>;
+export declare const ArithmeticUnaryTable: OperatorTable<UnaryOp<number, number | string>>;

package/dist/src/interpreter/components/Operations.js

@@ -0,0 +1,84 @@
+import { isArrayOfNumbers } from "../utils.js";
+export const ArithmeticBinaryTable = {
+    Plus: (a, b) => a + b,
+    Minus: (a, b) => a - b,
+    Multiply: (a, b) => a * b,
+    Divide: (a, b) => a / b,
+    Modulo: (a, b) => a % b,
+    Power: (a, b) => a ** b,
+    Min: (a, b) => Math.min(a, b),
+    Max: (a, b) => Math.max(a, b),
+};
+export const ComparisonOperationTable = {
+    Equal: (a, b) => a == b,
+    NotEqual: (a, b) => a != b,
+    Same: (a, b) => a === b,
+    NotSame: (a, b) => a !== b,
+    //Similar: (a, b) => ,
+    //NotSimilar: (a, b) => ,
+    GreaterOrEqualThan: (a, b) => a >= b,
+    GreaterThan: (a, b) => a > b,
+    LessOrEqualThan: (a, b) => a <= b,
+    LessThan: (a, b) => a < b,
+};
+export const LogicalBinaryTable = {
+    And: (left, rightThunk) => left && rightThunk(),
+    Or: (left, rightThunk) => left || rightThunk(),
+};
+export const BitwiseBinaryTable = {
+    BitwiseOr: (a, b) => a | b,
+    BitwiseAnd: (a, b) => a & b,
+    BitwiseLeftShift: (a, b) => a << b,
+    BitwiseRightShift: (a, b) => a >> b,
+    BitwiseUnsignedRightShift: (a, b) => a >>> b,
+    BitwiseXor: (a, b) => a ^ b,
+};
+export const StringOperationTable = {
+    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,
+};
+export const LogicalUnaryTable = {
+    Negation: (a) => !a,
+};
+export const ListBinaryTable = {
+    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,
+    DetectMax: (a) => {
+        if (!isArrayOfNumbers(a))
+            throw new Error("Operand of DetectMax must be Array of numbers");
+        return Math.max(...a);
+    },
+    DetectMin: (a) => {
+        if (!isArrayOfNumbers(a))
+            throw new Error("Operand of DetectMin must be Array of numbers");
+        return Math.min(...a);
+    },
+    Flatten: (a) => a.flat(),
+};
+export const ArithmeticUnaryTable = {
+    Round: (a) => Math.round(a),
+    Absolute: (a) => Math.abs(a),
+    Ceil: (a) => Math.ceil(a),
+    Floor: (a) => Math.floor(a),
+    Negation: (a) => a * -1,
+    Sqrt: (a) => Math.sqrt(a),
+    ToString: (a) => String(a),
+};

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

@@ -0,0 +1,73 @@
+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;
+    visitLiteralPattern(node: LiteralPattern): string;
+    visitTuplePattern(node: TuplePattern): string;
+    visitListPattern(node: ListPattern): string;
+    visitConsPattern(node: ConsPattern): string;
+    visitConstructorPattern(node: ConstructorPattern): string;
+    visitFunctorPattern(node: FunctorPattern): string;
+    visitApplicationPattern(node: ApplicationPattern): string;
+    visitAsPattern(node: AsPattern): string;
+    visitTypePattern(node: TypePattern): string;
+    visit(node: ASTNode): string;
+    fallback(node: ASTNode): string;
+}
+/**
+ * Recursively matches a value against a pattern node.
+ * Updates `bindings` when variables are bound successfully.
+ * Returns true if the pattern matches, false otherwise.
+ */
+export declare class PatternMatcher implements Visitor<CPSThunk<boolean>> {
+    private value;
+    private bindings;
+    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): CPSThunk<boolean>;
+    visitTypePattern(node: TypePattern): CPSThunk<boolean>;
+    private resolveCons;
+    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>;
+    fallback(node: ASTNode): CPSThunk<boolean>;
+}
+export {};