yukigo 0.2.2 → 0.3.1

package/dist/src/analyzer/utils.js

@@ -1,78 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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 {};