yukigo 0.1.0

package/src/interpreter/components/LazyRuntime.ts

@@ -0,0 +1,97 @@
+import {
+  PrimitiveValue,
+  RangeExpression,
+  ConsExpression,
+  isLazyList,
+  LazyList,
+} from "yukigo-ast";
+import { createStream, ExpressionEvaluator } from "../utils.js";
+
+export class LazyRuntime {
+  static realizeList(val: PrimitiveValue): PrimitiveValue[] {
+    if (Array.isArray(val)) return val;
+    if (isLazyList(val)) {
+      const result: PrimitiveValue[] = [];
+      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: RangeExpression,
+    evaluator: ExpressionEvaluator,
+    config: any
+  ): PrimitiveValue {
+    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: number[] = [];
+    let current = startVal;
+    const cond = step > 0 ? () => current <= endVal : () => current >= endVal;
+
+    while (cond()) {
+      result.push(current);
+      current += step;
+    }
+    return result;
+  }
+
+  static evaluateCons(
+    node: ConsExpression,
+    evaluator: ExpressionEvaluator,
+    lazy: boolean
+  ): PrimitiveValue {
+    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/src/interpreter/components/LogicEngine.ts

@@ -0,0 +1,227 @@
+import {
+  Exist,
+  Expression,
+  Findall,
+  Goal,
+  LiteralPattern,
+  Pattern,
+  PrimitiveValue,
+  Query,
+  SymbolPrimitive,
+  Variable,
+  VariablePattern,
+} from "yukigo-ast";
+import {
+  InternalLogicResult,
+  solveGoal,
+  Substitution,
+  success,
+} from "./LogicResolver.js";
+import { PatternResolver } from "./PatternMatcher.js";
+import { EnvStack, InterpreterConfig } from "../index.js";
+import { createStream, ExpressionEvaluator } from "../utils.js";
+import { InterpreterError } from "../errors.js";
+
+export class LogicEngine {
+  constructor(
+    private env: EnvStack,
+    private config: InterpreterConfig,
+    private evaluator: ExpressionEvaluator
+  ) {}
+
+  public solveQuery(node: Query): PrimitiveValue {
+    return this.evaluator.evaluate(node.expression);
+  }
+
+  public solveGoal(node: Goal): PrimitiveValue {
+    const patterns = node.args;
+    const generator = solveGoal(
+      this.env,
+      node.identifier.value,
+      patterns,
+      (body, substs) => this.solveConjunction(body, substs)
+    );
+    return this.handleOutputMode(generator);
+  }
+
+  public solveFindall(node: Findall): PrimitiveValue {
+    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: PrimitiveValue[] = [];
+    for (const res of generator)
+      results.push(this.instantiateTemplate(node.template, res.substs));
+
+    return results;
+  }
+
+  public solveExist(node: Exist): PrimitiveValue {
+    const generator = solveGoal(
+      this.env,
+      node.identifier.value,
+      node.patterns,
+      (body, substs) => this.solveConjunction(body, substs)
+    );
+    return this.handleOutputMode(generator);
+  }
+
+  private *solveConjunction(
+    expressions: Expression[],
+    substs: Substitution
+  ): Generator<InternalLogicResult> {
+    if (expressions.length === 0) {
+      yield success(substs);
+      return;
+    }
+
+    const [head, ...tail] = expressions;
+    let headGen: Generator<InternalLogicResult> | null = 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);
+    }
+  }
+
+  private expressionToPattern(expr: Expression): Pattern {
+    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;
+    }
+  }
+
+  private primitiveToPattern(val: PrimitiveValue): Pattern {
+    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`
+    );
+  }
+
+  private instantiateExpressionAsPattern(
+    expr: Expression,
+    substs: Substitution
+  ): Pattern {
+    const patternBase = this.expressionToPattern(expr);
+    return this.substitutePattern(patternBase, substs);
+  }
+
+  private substitutePattern(
+    pat: Pattern,
+    substs: Substitution,
+    visited: Set<string> = new Set()
+  ): Pattern {
+    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;
+  }
+
+  private instantiateTemplate(
+    template: Expression,
+    substs: Substitution
+  ): PrimitiveValue {
+    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");
+  }
+
+  private handleOutputMode(
+    gen: Generator<InternalLogicResult>
+  ): PrimitiveValue {
+    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`
+        );
+    }
+  }
+
+  private formatLogicResult(substs: Substitution): any {
+    const solutions = new Map<string, string>();
+    const resolver = new PatternResolver();
+    substs.forEach((pattern, key) => {
+      solutions.set(key, pattern.accept(resolver));
+    });
+    return { success: true, solutions };
+  }
+}

package/src/interpreter/components/LogicResolver.ts

@@ -0,0 +1,130 @@
+import {
+  Expression,
+  Fact,
+  FunctorPattern,
+  Goal,
+  ListPattern,
+  LiteralPattern,
+  Pattern,
+  PrimitiveValue,
+  Rule,
+  VariablePattern,
+  WildcardPattern,
+  isRuntimePredicate,
+} from "yukigo-ast";
+import { EnvStack } from "../index.js";
+import { lookup } from "../utils.js";
+import { InterpreterError } from "../errors.js";
+
+export type Substitution = Map<string, Pattern>;
+
+export type InternalLogicResult = { success: true; substs: Substitution };
+
+export type BodySolver = (
+  expressions: Expression[],
+  env: Substitution
+) => Generator<InternalLogicResult>;
+
+export function success(substs: Substitution): InternalLogicResult {
+  return { success: true, substs };
+}
+
+function unifyParameters(
+  patterns: Pattern[],
+  args: Pattern[]
+): [Substitution, boolean] {
+  const subst: Substitution = 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: EnvStack,
+  predicateName: string,
+  args: Pattern[],
+  solveBody: BodySolver
+): Generator<InternalLogicResult> {
+  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: Pattern, env: Substitution): Pattern {
+  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: Pattern,
+  t2: Pattern,
+  argEnv?: Substitution
+): Substitution | null {
+  const env: Substitution = 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/interpreter/components/Operations.ts

@@ -0,0 +1,81 @@
+import { PrimitiveValue } from "yukigo-ast";
+import { isArrayOfNumbers } from "../utils.js";
+
+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 const ArithmeticBinaryTable: OperatorTable<BinaryOp<number>> = {
+  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: OperatorTable<BinaryOp<boolean>> = {
+  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: OperatorTable<
+  (l: boolean, r: () => boolean) => boolean
+> = {
+  And: (left: boolean, rightThunk: () => boolean) => left && rightThunk(),
+  Or: (left: boolean, rightThunk: () => boolean) => left || rightThunk(),
+};
+
+export const BitwiseBinaryTable: OperatorTable<BinaryOp<number>> = {
+  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: OperatorTable<BinaryOp<string>> = {
+  Concat: (a, b) => `${a + b}`,
+};
+
+export const BitwiseUnaryTable: OperatorTable<UnaryOp<number>> = {
+  BitwiseNot: (a) => ~a,
+};
+export const LogicalUnaryTable: OperatorTable<UnaryOp<boolean>> = {
+  Negation: (a: boolean) => !a,
+};
+export const ListBinaryTable: OperatorTable<BinaryOp<PrimitiveValue[]>> = {
+  Concat: (a, b) => a.concat(b),
+};
+export const ListUnaryTable: OperatorTable<UnaryOp<PrimitiveValue[], PrimitiveValue>> = {
+  Size: (a: PrimitiveValue[]) => a.length,
+  DetectMax: (a: PrimitiveValue[]) => {
+    if (!isArrayOfNumbers(a))
+      throw new Error("Operand of DetectMax must be Array of numbers");
+    return Math.max(...a);
+  },
+  DetectMin: (a: PrimitiveValue[]) => {
+    if (!isArrayOfNumbers(a))
+      throw new Error("Operand of DetectMin must be Array of numbers");
+    return Math.min(...a);
+  },
+  Flatten: (a: PrimitiveValue[]) => a.flat(),
+};
+export const ArithmeticUnaryTable: OperatorTable<UnaryOp<number>> = {
+  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),
+};