yukigo 0.1.0

package/dist/interpreter/components/EnvBuilder.js

@@ -0,0 +1,78 @@
+import { isRuntimePredicate, TraverseVisitor, } from "@yukigo/ast";
+import { define } from "../utils.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) {
+        super();
+        this.env = baseEnv ?? [new Map()];
+    }
+    build(ast) {
+        for (const node of ast)
+            node.accept(this);
+        return this.env;
+    }
+    visitFunction(node) {
+        const name = node.identifier.value;
+        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`);
+        }
+        let placeholder;
+        define(this.env, name, placeholder);
+        const equations = node.equations.map((eq) => ({
+            patterns: eq.patterns,
+            body: eq.body,
+        }));
+        const runtimeFunc = {
+            identifier: name,
+            arity,
+            equations,
+        };
+        define(this.env, name, runtimeFunc);
+    }
+    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],
+            });
+        }
+        else {
+            this.env[0].set(identifier, {
+                kind: "Fact",
+                identifier,
+                equations: [node],
+            });
+        }
+    }
+    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],
+            });
+        }
+        else {
+            this.env[0].set(identifier, {
+                kind: "Rule",
+                identifier,
+                equations: [node],
+            });
+        }
+    }
+    visit(node) {
+        return node.accept(this);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { EquationRuntime, PrimitiveValue } from "@yukigo/ast";
+import { EnvStack } from "../index.js";
+import { ExpressionEvaluator } from "../utils.js";
+export declare class FunctionRuntime {
+    static apply(funcName: string, equations: EquationRuntime[], args: PrimitiveValue[], currentEnv: EnvStack, evaluatorFactory: (env: EnvStack) => ExpressionEvaluator): PrimitiveValue;
+    private static patternsMatch;
+    private static evaluateSequence;
+}

package/dist/interpreter/components/FunctionRuntime.js

@@ -0,0 +1,52 @@
+import { UnguardedBody, Return, } from "@yukigo/ast";
+import { PatternMatcher } from "./PatternMatcher.js";
+import { InterpreterError } from "../errors.js";
+class NonExhaustivePatterns extends InterpreterError {
+    constructor(funcName) {
+        super("PatternMatch", `Non-exhaustive patterns in '${funcName}'`);
+    }
+}
+export class FunctionRuntime {
+    static apply(funcName, equations, args, currentEnv, evaluatorFactory) {
+        for (const eq of equations) {
+            if (eq.patterns.length !== args.length)
+                continue;
+            const bindings = [];
+            if (!FunctionRuntime.patternsMatch(eq, args, bindings))
+                continue;
+            const localEnv = new Map(bindings);
+            const newStack = [localEnv, ...currentEnv];
+            const scopeEvaluator = evaluatorFactory(newStack);
+            // UnguardedBody
+            if (eq.body instanceof UnguardedBody)
+                return this.evaluateSequence(eq.body.sequence, scopeEvaluator);
+            // GuardedBody
+            for (const guard of eq.body) {
+                const cond = scopeEvaluator.evaluate(guard.condition);
+                if (cond === true)
+                    return scopeEvaluator.evaluate(guard.body);
+            }
+        }
+        throw new NonExhaustivePatterns(funcName);
+    }
+    static patternsMatch(eq, args, bindings) {
+        for (let i = 0; i < args.length; i++) {
+            const matcher = new PatternMatcher(args[i], bindings);
+            if (!eq.patterns[i].accept(matcher))
+                return false;
+        }
+        return true;
+    }
+    static evaluateSequence(seq, evaluator) {
+        let result = undefined;
+        for (const stmt of seq.statements) {
+            if (stmt instanceof Return) {
+                return evaluator.evaluate(stmt.body);
+            }
+            else {
+                result = evaluator.evaluate(stmt);
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { PrimitiveValue, RangeExpression, ConsExpression } from "@yukigo/ast";
+import { ExpressionEvaluator } from "../utils.js";
+export declare class LazyRuntime {
+    static realizeList(val: PrimitiveValue): PrimitiveValue[];
+    static evaluateRange(node: RangeExpression, evaluator: ExpressionEvaluator, config: any): PrimitiveValue;
+    static evaluateCons(node: ConsExpression, evaluator: ExpressionEvaluator, lazy: boolean): PrimitiveValue;
+}

package/dist/interpreter/components/LazyRuntime.js

@@ -0,0 +1,75 @@
+import { isLazyList, } from "@yukigo/ast";
+import { createStream } from "../utils.js";
+export class LazyRuntime {
+    static realizeList(val) {
+        if (Array.isArray(val))
+            return val;
+        if (isLazyList(val)) {
+            const result = [];
+            const iter = val.generator();
+            let next = iter.next();
+            while (!next.done) {
+                if (next.value === undefined)
+                    throw new Error("LazyList yielded undefined");
+                result.push(next.value);
+                next = iter.next();
+            }
+            return result;
+        }
+        throw new Error(`Expected List or LazyList, got ${typeof val}`);
+    }
+    static evaluateRange(node, evaluator, config) {
+        const startVal = evaluator.evaluate(node.start);
+        if (typeof startVal !== "number")
+            throw new Error("Range start must be a number");
+        const hasEnd = node.end != null;
+        let step = 1;
+        if (node.step) {
+            const secondVal = evaluator.evaluate(node.step);
+            if (typeof secondVal !== "number")
+                throw new Error("Range step must be a number");
+            step = secondVal - startVal;
+            if (step === 0)
+                throw new Error("Range step cannot be zero");
+        }
+        if (!hasEnd) {
+            return createStream(function* () {
+                let current = startVal;
+                while (true) {
+                    yield current;
+                    current += step;
+                }
+            });
+        }
+        const endVal = evaluator.evaluate(node.end);
+        if (typeof endVal !== "number")
+            throw new Error("Range end must be a number");
+        const result = [];
+        let current = startVal;
+        const cond = step > 0 ? () => current <= endVal : () => current >= endVal;
+        while (cond()) {
+            result.push(current);
+            current += step;
+        }
+        return result;
+    }
+    static evaluateCons(node, evaluator, lazy) {
+        const head = evaluator.evaluate(node.head);
+        if (lazy) {
+            const tail = evaluator.evaluate(node.tail);
+            if (Array.isArray(tail))
+                return [head, ...tail];
+            if (isLazyList(tail))
+                return createStream(function* () {
+                    yield head;
+                    yield* tail.generator();
+                });
+            throw new Error(`Invalid tail type for Cons: ${typeof tail}`);
+        }
+        // Eager behavior
+        const tail = evaluator.evaluate(node.tail);
+        if (isLazyList(tail) || !Array.isArray(tail))
+            throw new Error("Expected Array in eager Cons");
+        return [head, ...tail];
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Exist, Findall, Goal, PrimitiveValue, Query } from "@yukigo/ast";
+import { EnvStack, InterpreterConfig } from "../index.js";
+import { ExpressionEvaluator } from "../utils.js";
+export declare class LogicEngine {
+    private env;
+    private config;
+    private evaluator;
+    constructor(env: EnvStack, config: InterpreterConfig, evaluator: ExpressionEvaluator);
+    solveQuery(node: Query): PrimitiveValue;
+    solveGoal(node: Goal): PrimitiveValue;
+    solveFindall(node: Findall): PrimitiveValue;
+    solveExist(node: Exist): PrimitiveValue;
+    private solveConjunction;
+    private expressionToPattern;
+    private primitiveToPattern;
+    private instantiateExpressionAsPattern;
+    private substitutePattern;
+    private instantiateTemplate;
+    private handleOutputMode;
+    private formatLogicResult;
+}

package/dist/interpreter/components/LogicEngine.js

@@ -0,0 +1,152 @@
+import { Exist, Goal, LiteralPattern, SymbolPrimitive, Variable, VariablePattern, } from "@yukigo/ast";
+import { solveGoal, success, } from "./LogicResolver.js";
+import { PatternResolver } from "./PatternMatcher.js";
+import { createStream } from "../utils.js";
+import { InterpreterError } from "../errors.js";
+export class LogicEngine {
+    env;
+    config;
+    evaluator;
+    constructor(env, config, evaluator) {
+        this.env = env;
+        this.config = config;
+        this.evaluator = evaluator;
+    }
+    solveQuery(node) {
+        return this.evaluator.evaluate(node.expression);
+    }
+    solveGoal(node) {
+        const patterns = node.args;
+        const generator = solveGoal(this.env, node.identifier.value, patterns, (body, substs) => this.solveConjunction(body, substs));
+        return this.handleOutputMode(generator);
+    }
+    solveFindall(node) {
+        if (!(node.goal instanceof Goal))
+            throw new InterpreterError("solveFindall", "Findall expects a Goal");
+        const goalPatterns = node.goal.args.map((arg) => {
+            return this.expressionToPattern(arg);
+        });
+        const generator = solveGoal(this.env, node.goal.identifier.value, goalPatterns, (b, s) => this.solveConjunction(b, s));
+        const results = [];
+        for (const res of generator)
+            results.push(this.instantiateTemplate(node.template, res.substs));
+        return results;
+    }
+    solveExist(node) {
+        const generator = solveGoal(this.env, node.identifier.value, node.patterns, (body, substs) => this.solveConjunction(body, substs));
+        return this.handleOutputMode(generator);
+    }
+    *solveConjunction(expressions, substs) {
+        if (expressions.length === 0) {
+            yield success(substs);
+            return;
+        }
+        const [head, ...tail] = expressions;
+        let headGen = null;
+        if (head instanceof Goal) {
+            const args = head.args.map((arg) => this.instantiateExpressionAsPattern(arg, substs));
+            headGen = solveGoal(this.env, head.identifier.value, args, (b, s) => this.solveConjunction(b, s));
+        }
+        else if (head instanceof Exist) {
+            const patterns = head.patterns.map((pat) => this.substitutePattern(pat, substs));
+            headGen = solveGoal(this.env, head.identifier.value, patterns, (b, s) => this.solveConjunction(b, s));
+        }
+        if (headGen) {
+            // backtracking
+            for (const headResult of headGen) {
+                const newSubsts = new Map([...substs, ...headResult.substs]);
+                yield* this.solveConjunction(tail, newSubsts);
+            }
+        }
+        else {
+            // imperative
+            const result = this.evaluator.evaluate(head);
+            if (result)
+                yield* this.solveConjunction(tail, substs);
+        }
+    }
+    expressionToPattern(expr) {
+        if (expr instanceof VariablePattern)
+            return expr;
+        if (expr instanceof Variable) {
+            const name = expr.identifier.value;
+            if (/^[A-Z_]/.test(name))
+                return new VariablePattern(expr.identifier);
+        }
+        try {
+            const val = this.evaluator.evaluate(expr);
+            return this.primitiveToPattern(val);
+        }
+        catch (e) {
+            if (expr instanceof Variable)
+                return new VariablePattern(expr.identifier);
+            throw e;
+        }
+    }
+    primitiveToPattern(val) {
+        if (typeof val === "number" ||
+            typeof val === "string" ||
+            typeof val === "boolean")
+            return new LiteralPattern(new SymbolPrimitive(String(val)));
+        // TODO: Manejar arrays/listas complejas si es necesario
+        throw new InterpreterError("primitiveToPattern", `Cannot convert value ${val} to Logic Pattern`);
+    }
+    instantiateExpressionAsPattern(expr, substs) {
+        const patternBase = this.expressionToPattern(expr);
+        return this.substitutePattern(patternBase, substs);
+    }
+    substitutePattern(pat, substs, visited = new Set()) {
+        if (pat instanceof VariablePattern) {
+            const name = pat.name.value;
+            if (visited.has(name))
+                return pat;
+            const val = substs.get(name);
+            if (val) {
+                const newVisited = new Set(visited);
+                newVisited.add(name);
+                return this.substitutePattern(val, substs, newVisited);
+            }
+        }
+        return pat;
+    }
+    instantiateTemplate(template, substs) {
+        const pat = this.instantiateExpressionAsPattern(template, substs);
+        if (pat instanceof LiteralPattern)
+            return this.evaluator.evaluate(pat.name);
+        throw new Error("Complex template instantiation not fully implemented");
+    }
+    handleOutputMode(gen) {
+        const mode = this.config.outputMode || "first";
+        switch (mode) {
+            case "stream": {
+                const self = this;
+                return createStream(function* () {
+                    for (const res of gen)
+                        yield self.formatLogicResult(res.substs);
+                });
+            }
+            case "all": {
+                const res = [];
+                for (const r of gen)
+                    res.push(this.formatLogicResult(r.substs));
+                return res;
+            }
+            case "first": {
+                const next = gen.next();
+                if (next.done)
+                    return false;
+                return this.formatLogicResult(next.value.substs);
+            }
+            default:
+                throw new InterpreterError("handleOutputMode", `Unsupported mode: ${mode}. Supported modes: all | stream | first`);
+        }
+    }
+    formatLogicResult(substs) {
+        const solutions = new Map();
+        const resolver = new PatternResolver();
+        substs.forEach((pattern, key) => {
+            solutions.set(key, pattern.accept(resolver));
+        });
+        return { success: true, solutions };
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Expression, Pattern } from "@yukigo/ast";
+import { EnvStack } from "../index.js";
+export type Substitution = Map<string, Pattern>;
+export type InternalLogicResult = {
+    success: true;
+    substs: Substitution;
+};
+export type BodySolver = (expressions: Expression[], env: Substitution) => Generator<InternalLogicResult>;
+export declare function success(substs: Substitution): InternalLogicResult;
+export declare function solveGoal(envs: EnvStack, predicateName: string, args: Pattern[], solveBody: BodySolver): Generator<InternalLogicResult>;
+export declare function unify(t1: Pattern, t2: Pattern, argEnv?: Substitution): Substitution | null;

package/dist/interpreter/components/LogicResolver.js

@@ -0,0 +1,87 @@
+import { Fact, FunctorPattern, ListPattern, LiteralPattern, Rule, VariablePattern, WildcardPattern, isRuntimePredicate, } from "@yukigo/ast";
+import { lookup } from "../utils.js";
+import { InterpreterError } from "../errors.js";
+export function success(substs) {
+    return { success: true, substs };
+}
+function unifyParameters(patterns, args) {
+    const subst = new Map();
+    for (let i = 0; i < patterns.length; i++) {
+        const match = unify(patterns[i], args[i], subst);
+        if (!match)
+            return [, false];
+        match.forEach((v, k) => subst.set(k, v));
+    }
+    return [subst, true];
+}
+export function* solveGoal(envs, predicateName, args, solveBody) {
+    const pred = lookup(envs, predicateName);
+    if (!pred || !isRuntimePredicate(pred))
+        return;
+    for (const clause of pred.equations) {
+        if (clause.patterns.length !== args.length)
+            continue;
+        const [substs, matches] = unifyParameters(clause.patterns, args);
+        if (!matches)
+            continue;
+        if (clause instanceof Fact) {
+            yield success(substs);
+            continue;
+        }
+        if (clause instanceof Rule) {
+            const bodyGenerator = solveBody(clause.expressions, substs);
+            for (const finalResult of bodyGenerator)
+                yield success(finalResult.substs);
+            continue;
+        }
+        throw new InterpreterError("*solveGoal", `Unexpected node: ${JSON.stringify(clause)}`);
+    }
+}
+function resolve(node, env) {
+    if (node instanceof VariablePattern) {
+        const name = node.name.toString();
+        if (env.has(name))
+            return resolve(env.get(name), env);
+    }
+    return node;
+}
+export function unify(t1, t2, argEnv) {
+    const env = argEnv ?? new Map();
+    const r1 = resolve(t1, env);
+    const r2 = resolve(t2, env);
+    if (r1 === r2)
+        return env;
+    if (r1 instanceof WildcardPattern || r2 instanceof WildcardPattern)
+        return env;
+    if (r1 instanceof VariablePattern) {
+        env.set(r1.name.value, r2);
+        return env;
+    }
+    if (r2 instanceof VariablePattern) {
+        env.set(r2.name.value, r1);
+        return env;
+    }
+    if (r1 instanceof LiteralPattern && r2 instanceof LiteralPattern)
+        return r1.name.equals(r2.name) ? env : null;
+    if (r1 instanceof FunctorPattern && r2 instanceof FunctorPattern) {
+        if (r1.identifier.value !== r2.identifier.value)
+            return null;
+        if (r1.args.length !== r2.args.length)
+            return null;
+        for (let i = 0; i < r1.args.length; i++) {
+            if (!unify(r1.args[i], r2.args[i], env))
+                return null;
+        }
+        return env;
+    }
+    if (r1 instanceof ListPattern && r2 instanceof ListPattern) {
+        if (r1.elements.length !== r2.elements.length)
+            return null;
+        for (let i = 0; i < r1.elements.length; i++) {
+            if (!unify(r1.elements[i], r2.elements[i], env))
+                return null;
+        }
+        return env;
+    }
+    return null;
+}

package/dist/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<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 ListUnaryTable: OperatorTable<UnaryOp<PrimitiveValue[], PrimitiveValue>>;
+export declare const ArithmeticUnaryTable: OperatorTable<UnaryOp<number>>;

package/dist/interpreter/components/Operations.js

@@ -0,0 +1,69 @@
+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) => `${a + b}`,
+};
+export const BitwiseUnaryTable = {
+    BitwiseNot: (a) => ~a,
+};
+export const LogicalUnaryTable = {
+    Negation: (a) => !a,
+};
+export const ListBinaryTable = {
+    Concat: (a, b) => a.concat(b),
+};
+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),
+};

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

@@ -0,0 +1,41 @@
+import { ApplicationPattern, AsPattern, ASTNode, ConsPattern, ConstructorPattern, FunctorPattern, ListPattern, LiteralPattern, PrimitiveValue, TuplePattern, UnionPattern, VariablePattern, Visitor, WildcardPattern } from "@yukigo/ast";
+import { Bindings } from "../index.js";
+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;
+    visit(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<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 matchList;
+    visitConsPattern(node: ConsPattern): 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;
+}