yukigo 0.1.0 → 0.2.0

package/dist/interpreter/components/LogicEngine.js

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

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

@@ -1,87 +0,0 @@
-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/src/analyzer/inspections/functional.ts

@@ -1,159 +0,0 @@
-import {
-  ApplicationPattern,
-  AsPattern,
-  ASTNode,
-  CompositionExpression,
-  ConsPattern,
-  ConstructorPattern,
-  Fact,
-  For,
-  Function,
-  FunctorPattern,
-  GuardedBody,
-  Lambda,
-  ListComprehension,
-  ListPattern,
-  LiteralPattern,
-  Rule,
-  StopTraversalException,
-  TraverseVisitor,
-  TuplePattern,
-  UnionPattern,
-  WildcardPattern,
-  Yield,
-} from "yukigo-ast";
-import { InspectionMap, executeVisitor } from "../utils.js";
-
-export class FunctionVisitor extends TraverseVisitor {
-  private readonly targetBinding: string;
-  protected isInsideTargetScope: boolean = false; // this flag helps to check nested functions inside the targetBinding scope
-  constructor(binding: string) {
-    super();
-    this.targetBinding = binding;
-  }
-  visitFunction(node: Function): void {
-    const currentFunctionName = node.identifier.value;
-
-    // if not inside scope then is top-level
-    if (!this.isInsideTargetScope) {
-      if (!this.targetBinding || currentFunctionName === this.targetBinding) {
-        this.isInsideTargetScope = true;
-        this.traverseCollection(node.equations);
-        this.isInsideTargetScope = false;
-        return;
-      }
-      return;
-    }
-    // if inside the scope of targetBinding then traverse
-    this.traverseCollection(node.equations);
-  }
-}
-
-export class UsesComposition extends FunctionVisitor {
-  visitCompositionExpression(node: CompositionExpression): void {
-    throw new StopTraversalException();
-  }
-}
-export class UsesAnonymousVariable extends TraverseVisitor {
-  private readonly targetBinding: string;
-  protected isInsideTargetScope: boolean = false;
-
-  constructor(binding: string) {
-    super();
-    this.targetBinding = binding;
-  }
-
-  visitWildcardPattern(node: WildcardPattern): void {
-    throw new StopTraversalException();
-  }
-  visitFunction(node: Function): void {
-    this.enterScope(node, node.equations);
-  }
-  visitFact(node: Fact): void {
-    this.enterScope(node, node.patterns);
-  }
-  visitRule(node: Rule): void {
-    this.enterScope(node, node.patterns);
-  }
-  private enterScope(node: Function | Fact | Rule, children: ASTNode[]): void {
-    const nodeName = node.identifier.value;
-    if (!this.isInsideTargetScope) {
-      if (!this.targetBinding || nodeName === this.targetBinding) {
-        this.isInsideTargetScope = true;
-        this.traverseCollection(children);
-        this.isInsideTargetScope = false;
-      }
-      return;
-    }
-    this.traverseCollection(children);
-  }
-}
-export class UsesComprehension extends FunctionVisitor {
-  visitListComprehension(node: ListComprehension): void {
-    throw new StopTraversalException();
-  }
-}
-export class UsesGuards extends FunctionVisitor {
-  visitGuardedBody(node: GuardedBody): void {
-    throw new StopTraversalException();
-  }
-}
-export class UsesLambda extends FunctionVisitor {
-  visitLambda(node: Lambda): void {
-    throw new StopTraversalException();
-  }
-}
-export class UsesYield extends FunctionVisitor {
-  visitYield(node: Yield): void {
-    throw new StopTraversalException();
-  }
-}
-export class UsesPatternMatching extends FunctionVisitor {
-  visitConsPattern(node: ConsPattern): void {
-    throw new StopTraversalException();
-  }
-  visitAsPattern(node: AsPattern): void {
-    throw new StopTraversalException();
-  }
-  visitListPattern(node: ListPattern): void {
-    throw new StopTraversalException();
-  }
-  visitTuplePattern(node: TuplePattern): void {
-    throw new StopTraversalException();
-  }
-  visitLiteralPattern(node: LiteralPattern): void {
-    throw new StopTraversalException();
-  }
-  visitApplicationPattern(node: ApplicationPattern): void {
-    throw new StopTraversalException();
-  }
-  visitConstructorPattern(node: ConstructorPattern): void {
-    throw new StopTraversalException();
-  }
-  visitUnionPattern(node: UnionPattern): void {
-    throw new StopTraversalException();
-  }
-  visitFunctorPattern(node: FunctorPattern): void {
-    throw new StopTraversalException();
-  }
-  visitWildcardPattern(node: WildcardPattern): void {
-    throw new StopTraversalException();
-  }
-}
-
-export const functionalInspections: InspectionMap = {
-  UsesComposition: (node, args, binding) =>
-    executeVisitor(node, new UsesComposition(binding)),
-  UsesAnonymousVariable: (node, args, binding) =>
-    executeVisitor(node, new UsesAnonymousVariable(binding)),
-  UsesComprehension: (node, args, binding) =>
-    executeVisitor(node, new UsesComprehension(binding)),
-  UsesGuards: (node, args, binding) =>
-    executeVisitor(node, new UsesGuards(binding)),
-  UsesLambda: (node, args, binding) =>
-    executeVisitor(node, new UsesLambda(binding)),
-  UsesYield: (node, args, binding) =>
-    executeVisitor(node, new UsesYield(binding)),
-  UsesPatternMatching: (node, args, binding) =>
-    executeVisitor(node, new UsesPatternMatching(binding)),
-};

package/src/analyzer/inspections/imperative.ts

@@ -1,129 +0,0 @@
-import {
-  Enumeration,
-  ForLoop,
-  Function,
-  Procedure,
-  Repeat,
-  StopTraversalException,
-  Switch,
-  TraverseVisitor,
-  While,
-} from "yukigo-ast";
-import { InspectionMap, executeVisitor } from "../utils.js";
-
-export class BindingVisitor extends TraverseVisitor {
-  private readonly targetBinding: string;
-  protected isInsideTargetScope: boolean = false; // this flag helps to check nested functions inside the targetBinding scope
-  constructor(binding: string) {
-    super();
-    this.targetBinding = binding;
-  }
-  visitProcedure(node: Procedure): void {
-    const currentFunctionName = node.identifier.value;
-
-    // if not inside scope then is top-level
-    if (!this.isInsideTargetScope) {
-      if (!this.targetBinding || currentFunctionName === this.targetBinding) {
-        this.isInsideTargetScope = true;
-        this.traverseCollection(node.equations);
-        this.isInsideTargetScope = false;
-        return;
-      }
-      return;
-    }
-    // if inside the scope of targetBinding then traverse
-    this.traverseCollection(node.equations);
-  }
-  visitFunction(node: Function): void {
-    const currentFunctionName = node.identifier.value;
-
-    // if not inside scope then is top-level
-    if (!this.isInsideTargetScope) {
-      if (!this.targetBinding || currentFunctionName === this.targetBinding) {
-        this.isInsideTargetScope = true;
-        this.traverseCollection(node.equations);
-        this.isInsideTargetScope = false;
-        return;
-      }
-      return;
-    }
-    // if inside the scope of targetBinding then traverse
-    this.traverseCollection(node.equations);
-  }
-}
-
-export class DeclaresEnumeration extends TraverseVisitor {
-  private readonly enumName: string;
-  constructor(enumName: string) {
-    super();
-    this.enumName = enumName;
-  }
-  visitEnumeration(node: Enumeration): void {
-    if (node.identifier.value === this.enumName) throw StopTraversalException;
-  }
-}
-export class DeclaresProcedure extends TraverseVisitor {
-  private readonly procedureName: string;
-  constructor(procedureName: string) {
-    super();
-    this.procedureName = procedureName;
-  }
-  visitProcedure(node: Procedure): void {
-    if (node.identifier.value === this.procedureName)
-      throw StopTraversalException;
-  }
-}
-export class UsesForLoop extends BindingVisitor {
-  visitForLoop(node: ForLoop): void {
-    throw StopTraversalException;
-  }
-}
-export class UsesWhile extends BindingVisitor {
-  visitWhile(node: While): void {
-    throw StopTraversalException;
-  }
-}
-export class UsesRepeat extends BindingVisitor {
-  visitRepeat(node: Repeat): void {
-    throw StopTraversalException;
-  }
-}
-export class UsesLoop extends BindingVisitor {
-  visitForLoop(node: ForLoop): void {
-    throw StopTraversalException;
-  }
-  visitWhile(node: While): void {
-    throw StopTraversalException;
-  }
-  visitRepeat(node: Repeat): void {
-    throw StopTraversalException;
-  }
-  // visitForEach(node: ForEach): void {
-  //   throw StopTraversalException;
-  // }
-}
-export class UsesSwitch extends BindingVisitor {
-  visitSwitch(node: Switch): void {
-    throw StopTraversalException;
-  }
-}
-
-export const imperativeInspections: InspectionMap = {
-  DeclaresEnumeration: (node, args) =>
-    executeVisitor(node, new DeclaresEnumeration(args[0])),
-  DeclaresProcedure: (node, args) =>
-    executeVisitor(node, new DeclaresProcedure(args[0])),
-  UsesForEach: (node, args) => {
-    throw Error("Inspection not implemented");
-  },
-  UsesForLoop: (node, args, binding) =>
-    executeVisitor(node, new UsesForLoop(binding)),
-  UsesRepeat: (node, args, binding) =>
-    executeVisitor(node, new UsesRepeat(binding)),
-  UsesWhile: (node, args, binding) =>
-    executeVisitor(node, new UsesWhile(binding)),
-  UsesLoop: (node, args, binding) =>
-    executeVisitor(node, new UsesLoop(binding)),
-  UsesSwitch: (node, args, binding) =>
-    executeVisitor(node, new UsesSwitch(binding)),
-};

package/src/analyzer/inspections/logic.ts

@@ -1,166 +0,0 @@
-import {
-  Assignment,
-  AssignOperation,
-  Exist,
-  Fact,
-  Findall,
-  Forall,
-  Not,
-  Rule,
-  StopTraversalException,
-  SymbolPrimitive,
-  TraverseVisitor,
-  UnifyOperation,
-} from "yukigo-ast";
-import { InspectionMap, executeVisitor } from "../utils.js";
-import { isYukigoPrimitive } from "yukigo-ast";
-
-export abstract class DeclaresBinding extends TraverseVisitor {
-  protected readonly targetBinding: string;
-
-  constructor(binding: string) {
-    super();
-    this.targetBinding = binding;
-  }
-}
-export class DeclaresFact extends DeclaresBinding {
-  visitFact(node: Fact): void {
-    const bindingName = node.identifier.value;
-    if (!this.targetBinding || bindingName === this.targetBinding)
-      throw new StopTraversalException();
-  }
-}
-export class DeclaresRule extends DeclaresBinding {
-  visitRule(node: Rule): void {
-    const bindingName = node.identifier.value;
-    if (!this.targetBinding || bindingName === this.targetBinding)
-      throw new StopTraversalException();
-  }
-}
-export class DeclaresPredicate extends DeclaresBinding {
-  visitFact(node: Fact): void {
-    new DeclaresFact(this.targetBinding).visitFact(node);
-  }
-  visitRule(node: Rule): void {
-    new DeclaresRule(this.targetBinding).visitRule(node);
-  }
-}
-
-export class PredicateVisitor extends TraverseVisitor {
-  private readonly targetBinding: string;
-  protected isInsideTargetScope: boolean = false; // this flag helps to check nested functions inside the targetBinding scope
-  constructor(binding: string) {
-    super();
-    this.targetBinding = binding;
-  }
-  visitFact(node: Fact): void {
-    const nodeName = node.identifier.value;
-    if (!this.isInsideTargetScope) {
-      if (nodeName === this.targetBinding) {
-        this.isInsideTargetScope = true;
-        this.traverseCollection(node.patterns);
-        this.isInsideTargetScope = false;
-      }
-      return;
-    }
-    this.traverseCollection(node.patterns);
-  }
-  visitRule(node: Rule): void {
-    const nodeName = node.identifier.value;
-    if (!this.isInsideTargetScope) {
-      if (nodeName === this.targetBinding) {
-        this.isInsideTargetScope = true;
-        this.traverseCollection(node.expressions);
-        this.isInsideTargetScope = false;
-      }
-      return;
-    }
-    this.traverseCollection(node.expressions);
-  }
-}
-
-export class UsesFindall extends TraverseVisitor {
-  visitFindall(node: Findall): void {
-    throw new StopTraversalException();
-  }
-}
-export class UsesForall extends TraverseVisitor {
-  visitForall(node: Forall): void {
-    throw new StopTraversalException();
-  }
-}
-export class UsesNot extends TraverseVisitor {
-  visitNot(node: Not): void {
-    throw new StopTraversalException();
-  }
-  visitExist(node: Exist): void {
-    if (node.identifier.value === "not") throw new StopTraversalException();
-  }
-}
-export class UsesUnificationOperator extends PredicateVisitor {
-  visitUnifyOperation(node: UnifyOperation): void {
-    throw new StopTraversalException();
-  }
-}
-export class UsesCut extends PredicateVisitor {
-  visitExist(node: Exist): void {
-    if (node.identifier.value === "!") throw new StopTraversalException();
-  }
-}
-export class UsesFail extends PredicateVisitor {
-  visitExist(node: Exist): void {
-    if (node.identifier.value === "fail") throw new StopTraversalException();
-  }
-}
-export class HasRedundantReduction extends TraverseVisitor {
-  private readonly targetBinding: string;
-  protected isInsideTargetScope: boolean = false;
-
-  constructor(binding: string) {
-    super();
-    this.targetBinding = binding;
-  }
-  visitRule(node: Rule): void {
-    // Only inspect the specified rule if a binding is provided
-    if (this.targetBinding && node.identifier.value !== this.targetBinding)
-      return;
-
-    // Check each unification in the rule's body
-    for (const bodyElement of node.expressions) {
-      if (bodyElement instanceof AssignOperation) {
-        const left = bodyElement.left;
-        const right = bodyElement.right;
-
-        if (!(left instanceof SymbolPrimitive)) continue;
-
-        const redundantReductionParameters = isYukigoPrimitive(right);
-        const redundantReductionFunctors = right instanceof Exist;
-
-        // Check if reduction is redundant
-        const isRedundant =
-          redundantReductionParameters || redundantReductionFunctors;
-
-        if (isRedundant) throw new StopTraversalException();
-      }
-    }
-  }
-}
-
-export const logicInspections: InspectionMap = {
-  DeclaresFact: (node, args, binding) =>
-    executeVisitor(node, new DeclaresFact(binding)),
-  DeclaresRule: (node, args, binding) =>
-    executeVisitor(node, new DeclaresRule(binding)),
-  DeclaresPredicate: (node, args, binding) =>
-    executeVisitor(node, new DeclaresPredicate(binding)),
-  UsesFindall: (node, args, binding) => executeVisitor(node, new UsesFindall()),
-  UsesForall: (node, args, binding) => executeVisitor(node, new UsesForall()),
-  UsesNot: (node, args, binding) => executeVisitor(node, new UsesNot()),
-  UsesUnificationOperator: (node, args, binding) =>
-    executeVisitor(node, new UsesUnificationOperator(binding)),
-  UsesCut: (node, args, binding) => executeVisitor(node, new UsesCut(binding)),
-  UsesFail: (node, args, binding) =>
-    executeVisitor(node, new UsesFail(binding)),
-  HasRedundantReduction: (node, args, binding) =>
-    executeVisitor(node, new HasRedundantReduction(binding)),
-};