yukigo 0.1.1 → 0.2.0

package/dist/interpreter/entities.js

@@ -0,0 +1,96 @@
+export function isLogicResult(value) {
+    return (value &&
+        typeof value === "object" &&
+        "success" in value &&
+        typeof value.success === "boolean" &&
+        "solutions" in value &&
+        value.solutions instanceof Map);
+}
+export class RuntimePredicate {
+    kind;
+    identifier;
+    equations;
+    constructor(kind, identifier, equations) {
+        this.kind = kind;
+        this.identifier = identifier;
+        this.equations = equations;
+    }
+    pushEquation(eq) {
+        this.equations.push(eq);
+    }
+}
+// TODO: Replace with correct polymorphism
+export const isRuntimePredicate = (prim) => {
+    return prim instanceof RuntimePredicate;
+};
+export class RuntimeEquation {
+    patterns;
+    body;
+    constructor(patterns, body) {
+        this.patterns = patterns;
+        this.body = body;
+    }
+}
+export class RuntimeFunction {
+    arity;
+    identifier;
+    equations;
+    pendingArgs;
+    closure;
+    constructor(arity, identifier, equations, pendingArgs, closure) {
+        this.arity = arity;
+        this.identifier = identifier;
+        this.equations = equations;
+        this.pendingArgs = pendingArgs;
+        this.closure = closure;
+    }
+    setPendingArgs(args) {
+        this.pendingArgs = args;
+    }
+}
+// TODO: Replace with correct polymorphism
+export function isRuntimeFunction(val) {
+    return val instanceof RuntimeFunction;
+}
+export class RuntimeClass {
+    identifier;
+    fields;
+    methods;
+    mixins;
+    superclass;
+    constructor(identifier, fields, methods, mixins, superclass) {
+        this.identifier = identifier;
+        this.fields = fields;
+        this.methods = methods;
+        this.mixins = mixins;
+        this.superclass = superclass;
+    }
+}
+// TODO: prev as before
+export function isRuntimeClass(val) {
+    return val instanceof RuntimeClass;
+}
+export class RuntimeObject {
+    identifier;
+    className;
+    fields;
+    methods;
+    constructor(identifier, className, fields, methods) {
+        this.identifier = identifier;
+        this.className = className;
+        this.fields = fields;
+        this.methods = methods;
+    }
+}
+export function isRuntimeObject(val) {
+    return val instanceof RuntimeObject;
+}
+export class LazyList {
+    generator;
+    constructor(generator) {
+        this.generator = generator;
+    }
+}
+export function isLazyList(prim) {
+    return prim instanceof LazyList;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yukigo",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,7 +15,7 @@
   "dependencies": {
     "typescript": "^5.9.2",
     "yaml": "^2.8.0",
-    "yukigo-ast": "0.1.1"
+    "yukigo-ast": "^0.2.0"
   },
   "devDependencies": {
     "@types/chai": "^5.2.2",

package/src/analyzer/index.ts

@@ -22,7 +22,7 @@ export type AnalysisResult = {
 export type InspectionRule = {
   inspection: string;
   binding?: string;
-  args: string[];
+  args?: string[];
   expected: boolean;
 };
 
@@ -154,7 +154,8 @@ export class Analyzer {
       // Execution Loop
       const isGlobalVisitor = !rule.binding || rule.binding === "*";
       const normalizedBinding = isGlobalVisitor ? undefined : rule.binding;
-      const visitor = new InspectionClass(...rule.args, normalizedBinding);
+      const args = rule.args ?? []
+      const visitor = new InspectionClass(...args, normalizedBinding);
 
       for (const { node, binding } of targets) {
         try {

package/src/interpreter/components/PatternMatcher.ts

@@ -21,6 +21,7 @@ import {
   TypePattern,
   SimpleType,
   ListType,
+  EnvStack,
 } from "yukigo-ast";
 import { Bindings } from "../index.js";
 import { InterpreterVisitor } from "./Visitor.js";
@@ -61,6 +62,7 @@ export interface InternalConsState {
   readonly head: PrimitiveValue;
   readonly tailExpr: Expression;
   readonly evaluator: ExpressionEvaluator;
+  readonly capturedEnv: EnvStack;
   realizedTail?: PrimitiveValue;
 }
 

package/src/interpreter/components/RuntimeContext.ts

@@ -4,7 +4,6 @@ import { LazyRuntime } from "./runtimes/LazyRuntime.js";
 import { ObjectRuntime } from "./runtimes/ObjectRuntime.js";
 import { createGlobalEnv } from "../utils.js";
 import { UnboundVariable } from "../errors.js";
-import { inspect } from "util";
 
 export const DefaultConfiguration: Required<InterpreterConfig> = {
   lazyLoading: false,
@@ -87,12 +86,12 @@ export class RuntimeContext {
 
     return false;
   }
-  public popEnv(env: EnvStack) {
-    if (!env.tail)
+  public popEnv() {
+    if (!this.env.tail)
       throw new Error(
         "Runtime Error: Cannot pop the global environment scope.",
       );
-    this.env = env.tail;
+    this.env = this.env.tail;
   }
   public lookup(name: string): PrimitiveValue {
     let current: EnvStack | null = this.env;
@@ -110,4 +109,11 @@ export class RuntimeContext {
   public define(name: string, value: PrimitiveValue): void {
     this.env.head.set(name, value);
   }
+  public clone(env?: EnvStack): EnvStack {
+    const target = env ?? this.env;
+    return {
+      head: new Map(target.head),
+      tail: this.env.tail,
+    };
+  }
 }

package/src/interpreter/components/TestRunner.ts

@@ -2,6 +2,7 @@ import {
   Assert,
   Equality,
   Failure,
+  isLazyList,
   PrimitiveValue,
   Test,
   TestGroup,
@@ -84,18 +85,17 @@ class AssertionVisitor extends TraverseVisitor {
       this.interpreter.evaluate(node.value, (value) => {
         return () =>
           this.interpreter.evaluate(node.expected, (expected) => {
-            return this.isEqual(value, expected, (passed) => {
+            this.lazyRuntime.deepEqual(value, expected, (passed) => {
               if (this.negated === passed) {
                 throw new FailedAssert(
-                  value,
-                  expected,
+                  value, expected,
                   this.negated
                     ? `Expected ${JSON.stringify(value)} NOT to be equal to ${JSON.stringify(expected)}`
                     : `Expected ${JSON.stringify(expected)}, but got ${JSON.stringify(value)}`,
                 );
               }
               return k(undefined);
-            });
+            })
           });
       });
   }
@@ -116,42 +116,6 @@ class AssertionVisitor extends TraverseVisitor {
         return k(undefined);
       });
   }
-  private isEqual(a: any, b: any, k: Continuation<boolean>): Thunk<boolean> {
-    if (a === b) return k(true);
-    if (a && b && typeof a === "object" && typeof b === "object") {
-      return this.lazyRuntime.realizeList(a, (valA) => {
-        return () =>
-          this.lazyRuntime.realizeList(b, (valB) => {
-            if (Array.isArray(valA) && Array.isArray(valB)) {
-              if (valA.length !== valB.length) return k(false);
-              const checkNext = (index: number): Thunk<boolean> => {
-                if (index >= valA.length) return k(true);
-                return this.isEqual(valA[index], valB[index], (res) => {
-                  if (!res) return k(false);
-                  return () => checkNext(index + 1);
-                });
-              };
-              return checkNext(0);
-            }
-
-            if (Array.isArray(valA) !== Array.isArray(valB)) return k(false);
-
-            const keys = Object.keys(valA);
-            if (keys.length !== Object.keys(valB).length) return k(false);
-            const checkNextKey = (index: number): Thunk<boolean> => {
-              if (index >= keys.length) return k(true);
-              const key = keys[index];
-              return this.isEqual(valA[key], valB[key], (res) => {
-                if (!res) return k(false);
-                return () => checkNextKey(index + 1);
-              });
-            };
-            return checkNextKey(0);
-          });
-      });
-    }
-    return k(false);
-  }
 }
 
 export class TestRunner extends TraverseVisitor {

package/src/interpreter/components/Visitor.ts

@@ -378,6 +378,17 @@ export class InterpreterVisitor
   visitComparisonOperation(
     node: ComparisonOperation,
   ): CPSThunk<PrimitiveValue> {
+    if (node.operator === "Equal" || node.operator === "NotEqual") {
+      return (k) =>
+        this.evaluate(node.left, (left) => () =>
+          this.evaluate(node.right, (right) =>
+            this.context.lazyRuntime.deepEqual(left, right, (eq) =>
+              k(node.operator === "Equal" ? eq : !eq)
+            )
+          )
+        );
+    }
+
     return this.processBinary(
       node,
       ComparisonOperationTable,
@@ -684,6 +695,7 @@ export class InterpreterVisitor
   }
 
   visitApplication(node: Application): CPSThunk<PrimitiveValue> {
+    const { funcRuntime } = this.context
     if (this.context.config.debug) {
       console.log(`[Interpreter] Visiting Application`);
     }
@@ -695,53 +707,26 @@ export class InterpreterVisitor
             "Cannot apply non-function",
           );
 
-        return this.evaluate(node.parameter, (arg) => {
-          const argThunk = () => arg;
-          const allPendingArgs = func.pendingArgs
-            ? [...func.pendingArgs, argThunk]
-            : [argThunk];
-
-          return this.applyArguments(func, allPendingArgs)(k);
-        });
-      });
-  }
-
-  private applyArguments(
-    func: RuntimeFunction,
-    args: (PrimitiveValue | (() => PrimitiveValue))[],
-  ): CPSThunk<PrimitiveValue> {
-    if (args.length < func.arity) {
-      return valueToCPS({
-        ...func,
-        pendingArgs: args,
-      });
-    }
-
-    const argsToConsume = args.slice(0, func.arity);
-    const remainingArgs = args.slice(func.arity);
-
-    const evaluatedArgs = argsToConsume.map((arg) =>
-      typeof arg === "function" ? arg() : arg,
-    );
-
-    if (func.closure) this.context.pushEnv(func.closure.head);
-    return (cont) => () =>
-      this.context.funcRuntime.apply(func, evaluatedArgs, (result) => {
-        if (remainingArgs.length > 0) {
-          if (isRuntimeFunction(result)) {
-            const nextArgs = result.pendingArgs
-              ? [...result.pendingArgs, ...remainingArgs]
-              : remainingArgs;
-
-            return this.applyArguments(result, nextArgs)(cont);
-          } else {
-            throw new InterpreterError(
-              "Application",
-              `Too many arguments provided. Result was '${result}' (not a function), but had ${remainingArgs.length} args left.`,
-            );
-          }
+        const applyFuncToNode = (func: RuntimeFunction): CPSThunk<PrimitiveValue> => (k) =>
+          this.evaluate(node.parameter, (arg) => {
+            const argThunk = () => arg;
+            const allPendingArgs = func.pendingArgs
+              ? [...func.pendingArgs, argThunk]
+              : [argThunk];
+            return funcRuntime.applyArguments(func, allPendingArgs)(k);
+          });
+        if (func.arity === 0) {
+          return funcRuntime.applyArguments(func, [])(resultOfFunc => {
+            if (!isRuntimeFunction(resultOfFunc))
+              throw new InterpreterError(
+                "Application",
+                `Cannot apply non-function result of arity-0 function`,
+              );
+            return applyFuncToNode(resultOfFunc)(k);
+          });
         }
-        return cont(result);
+
+        return applyFuncToNode(func)(k);
       });
   }
 
@@ -985,7 +970,9 @@ export class InterpreterVisitor
       return process(0);
     };
   }
-
+  visitTypeCast(node: TypeCast): CPSThunk<PrimitiveValue> {
+    return node.expression.accept(this);
+  }
   visitGenerator(node: YuGenerator): CPSThunk<PrimitiveValue> {
     return (k) => this.evaluate(node.expression, k);
   }

package/src/interpreter/components/runtimes/FunctionRuntime.ts

@@ -4,16 +4,16 @@ import {
   UnguardedBody,
   Sequence,
   Return,
-  EnvStack,
   Function,
   RuntimeFunction,
+  isRuntimeFunction,
 } from "yukigo-ast";
 import { Bindings } from "../../index.js";
 import { PatternMatcher } from "../PatternMatcher.js";
 import { ExpressionEvaluator } from "../../utils.js";
 import { InterpreterError } from "../../errors.js";
 import { EnvBuilderVisitor } from "../EnvBuilder.js";
-import { Continuation, Thunk } from "../../trampoline.js";
+import { Continuation, CPSThunk, Thunk, valueToCPS } from "../../trampoline.js";
 import { RuntimeContext } from "../RuntimeContext.js";
 import { InterpreterVisitor } from "../Visitor.js";
 
@@ -35,6 +35,7 @@ export class FunctionRuntime {
   ): Thunk<PrimitiveValue> {
     const funcName = func.identifier;
     const equations = func.equations;
+    const oldEnv = this.context.env;
 
     if (this.context.config.debug)
       console.log(
@@ -44,6 +45,7 @@ export class FunctionRuntime {
 
     const tryNextEquation = (eqIndex: number): Thunk<PrimitiveValue> => {
       if (eqIndex >= equations.length) {
+        this.context.setEnv(oldEnv);
         throw new NonExhaustivePatterns(funcName);
       }
 
@@ -62,7 +64,6 @@ export class FunctionRuntime {
           );
 
         const localEnv = new Map<string, PrimitiveValue>(bindings);
-        const oldEnv = this.context.env;
         if (func.closure) this.context.setEnv(func.closure);
         this.context.pushEnv(localEnv);
 
@@ -124,6 +125,44 @@ export class FunctionRuntime {
     return tryNextEquation(0);
   }
 
+  public applyArguments(
+    func: RuntimeFunction,
+    args: (PrimitiveValue | (() => PrimitiveValue))[],
+  ): CPSThunk<PrimitiveValue> {
+    if (args.length < func.arity) {
+      return valueToCPS({
+        ...func,
+        pendingArgs: args,
+      });
+    }
+
+    const argsToConsume = args.slice(0, func.arity);
+    const remainingArgs = args.slice(func.arity);
+
+    const evaluatedArgs = argsToConsume.map((arg) =>
+      typeof arg === "function" ? arg() : arg,
+    );
+
+    return (cont) => () =>
+      this.apply(func, evaluatedArgs, (result) => {
+        if (remainingArgs.length > 0) {
+          if (isRuntimeFunction(result)) {
+            const nextArgs = result.pendingArgs
+              ? [...result.pendingArgs, ...remainingArgs]
+              : remainingArgs;
+
+            return this.applyArguments(result, nextArgs)(cont);
+          } else {
+            throw new InterpreterError(
+              "Application",
+              `Too many arguments provided. Result was '${result}' (not a function), but had ${remainingArgs.length} args left.`,
+            );
+          }
+        }
+        return cont(result);
+      });
+  }
+
   private preloadDefinitions(
     seq: Sequence,
     evaluatorFactory: EvaluatorFactory,

package/src/interpreter/components/runtimes/LazyRuntime.ts

@@ -118,14 +118,15 @@ export class LazyRuntime {
     evaluator: ExpressionEvaluator,
     k: Continuation<PrimitiveValue>,
   ): Thunk<PrimitiveValue> {
-    const capturedEnv = this.context.env;
     const ctx = this.context;
+    const capturedEnv = ctx.clone();
     return evaluator.evaluate(node.head, (head) => {
-      if (this.context.config.lazyLoading) {
+      if (ctx.config.lazyLoading) {
         const consState: InternalConsState = {
           head,
           tailExpr: node.tail,
           evaluator,
+          capturedEnv,
           realizedTail: undefined,
         };
 
@@ -140,13 +141,10 @@ export class LazyRuntime {
 
                 if (current.realizedTail === undefined) {
                   const prevEnv = ctx.env;
-                  ctx.setEnv(capturedEnv);
+                  ctx.setEnv(current.capturedEnv);
                   try {
                     current.realizedTail = trampoline(
-                      current.evaluator.evaluate(
-                        current.tailExpr,
-                        idContinuation,
-                      ),
+                      current.evaluator.evaluate(current.tailExpr, idContinuation),
                     );
                   } finally {
                     ctx.setEnv(prevEnv);
@@ -236,29 +234,34 @@ export class LazyRuntime {
     evaluator: ExpressionEvaluator,
     k: Continuation<PrimitiveValue>,
   ): Thunk<PrimitiveValue> {
-    const capturedEnv = this.context.env;
     const ctx = this.context;
-    return k(
-      createMemoizedStream(function* () {
-        const prevEnv = ctx.env;
-        ctx.setEnv(capturedEnv);
-        try {
-          const left = trampoline(evaluator.evaluate(node.left, idContinuation));
+
+    return evaluator.evaluate(node.left, (left) => {
+      const capturedEnv = ctx.clone();
+      return k(
+        createMemoizedStream(function* () {
           if (Array.isArray(left)) yield* left;
           else if (typeof left === "string") yield* left.split("");
           else if (isLazyList(left)) yield* left.generator();
+          else throw new Error("Invalid left operand for lazy Concat");
+
+          // right evaluates lazily on demand
+          const prevEnv = ctx.env;
+          ctx.setEnv(capturedEnv);
+          let right: PrimitiveValue;
+          try {
+            right = trampoline(evaluator.evaluate(node.right, idContinuation));
+          } finally {
+            ctx.setEnv(prevEnv);
+          }
 
-          const right = trampoline(
-            evaluator.evaluate(node.right, idContinuation),
-          );
           if (Array.isArray(right)) yield* right;
           else if (typeof right === "string") yield* right.split("");
           else if (isLazyList(right)) yield* right.generator();
-        } finally {
-          ctx.setEnv(prevEnv);
-        }
-      }),
-    );
+          else throw new Error("Invalid right operand for lazy Concat");
+        }),
+      );
+    });
   }
   public deepEqual<R = boolean>(
     a: PrimitiveValue,
@@ -267,35 +270,65 @@ export class LazyRuntime {
   ): Thunk<R> {
     if (a === b) return k(true);
 
-    const compareValues = (valA: any, valB: any): Thunk<R> => {
-      if (typeof valA === "string" && typeof valB === "string")
-        return k(valA === valB);
-
-      if (Array.isArray(valA) && Array.isArray(valB)) {
-        if (valA.length !== valB.length) return k(false);
-        const compareNext = (index: number): Thunk<R> => {
-          if (index >= valA.length) return k(true);
-          return () =>
-            this.deepEqual(valA[index], valB[index], (isEqual) => {
-              if (!isEqual) return k(false);
-              return () => compareNext(index + 1);
-            });
-        };
-        return compareNext(0);
-      }
-
-      return k(valA == valB);
-    };
+    const aIsListLike = this.isListLike(a);
+    const bIsListLike = this.isListLike(b);
+    const eitherIsCollection = this.isCollection(a) || this.isCollection(b);
 
-    if (isLazyList(a) || isLazyList(b)) {
-      return this.realizeList(a, (valA) => {
-        return () =>
-          this.realizeList(b, (valB) => {
-            return () => compareValues(valA, valB);
-          });
-      });
+    if (eitherIsCollection && aIsListLike && bIsListLike) {
+      return this.realizeList(a, (valA) => () =>
+        this.realizeList(b, (valB) => {
+          if (valA.length !== valB.length) return k(false);
+          return this.deepEqualCollection(valA, valB, 0, k);
+        })
+      );
     }
 
-    return compareValues(a, b);
+    if (eitherIsCollection) return k(false); // colección vs número → false
+
+    if (this.isPlainObject(a) && this.isPlainObject(b))
+      return this.deepEqualObject(a, b, k);
+
+    return k(a == b); // primitivos: number, boolean, string==number
+  }
+  private isPlainObject(val: unknown): val is Record<string, any> {
+    return val !== null && typeof val === "object"
+      && !isLazyList(val) && !Array.isArray(val);
+  }
+  private isCollection(val: unknown): val is PrimitiveValue[] | LazyList {
+    return Array.isArray(val) || isLazyList(val);
+  }
+
+  private isListLike(val: unknown): val is string | PrimitiveValue[] | LazyList {
+    return Array.isArray(val) || isLazyList(val) || typeof val === "string";
+  }
+  private deepEqualCollection<R>(
+    a: PrimitiveValue[],
+    b: PrimitiveValue[],
+    index: number,
+    k: Continuation<boolean, R>,
+  ): Thunk<R> {
+    if (index >= a.length) return k(true);
+    return this.deepEqual(a[index], b[index], (eq) => {
+      if (!eq) return k(false);
+      return () => this.deepEqualCollection(a, b, index + 1, k);
+    });
+  }
+
+  private deepEqualObject<R>(
+    a: Record<string, any>,
+    b: Record<string, any>,
+    k: Continuation<boolean, R>,
+  ): Thunk<R> {
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) return k(false);
+    const checkNext = (index: number): Thunk<R> => {
+      if (index >= keys.length) return k(true);
+      const key = keys[index];
+      return this.deepEqual(a[key], b[key], (eq) => {
+        if (!eq) return k(false);
+        return () => checkNext(index + 1);
+      });
+    };
+    return checkNext(0);
   }
 }

package/tests/analyzer/generic.spec.ts

@@ -5,6 +5,7 @@ import {
   ParameterizedType,
   SymbolPrimitive,
   SimpleType,
+  Function,
 } from "yukigo-ast";
 
 describe("Generic Inspections", () => {
@@ -23,6 +24,19 @@ describe("Generic Inspections", () => {
     return new TypeSignature(identifier, body);
   };
 
+  it("should allow expectations without args", () => {
+    const ast = [new Function(new SymbolPrimitive("func"), [])];
+    const rules: InspectionRule[] = [
+      {
+        binding: "func",
+        inspection: "HasBinding",
+        expected: true
+      },
+    ];
+    const analyzer = new Analyzer();
+    const results = analyzer.analyze(ast, rules);
+    expect(results[0].passed).to.be.true;
+  });
   describe("TypesParameterAs", () => {
     it("should find a match when parameter type matches at correct index", () => {
       const ast = [createTypeSignature("f", ["Int", "String"], "Bool")];

package/tests/interpreter/interpreter.spec.ts

@@ -22,9 +22,11 @@ import {
   RangeExpression,
   Return,
   Sequence,
+  SimpleType,
   StringOperation,
   StringPrimitive,
   SymbolPrimitive,
+  TypeCast,
   UnguardedBody,
   Variable,
   VariablePattern,
@@ -892,6 +894,14 @@ describe("Interpreter Spec", () => {
       assert.equal(res, 16);
     });
   });
+  describe("Evaluates TypeCast", () => {
+    it("Type casting of number 2 to string should be '2'", () => {
+      const res = interpreter.evaluate(
+        new TypeCast(new NumberPrimitive(2), new SimpleType("String", [])),
+      );
+      assert.equal(res, "2");
+    });
+  });
   describe("Evaluates Range Expression", () => {
     it("Evaluates [1..5] to full range", () => {
       const range = new RangeExpression(