yukigo 0.1.1 → 0.2.2

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/src/utils/helpers.ts

@@ -1,11 +1,26 @@
 import { parseDocument } from "yaml";
-import { InspectionRule } from "../analyzer/index.js";
+import {
+  InspectionRule,
+  TargetSuffix,
+} from "../analyzer/index.js";
+
+const declareMap: Record<string, string> = {
+  HasBinding: "Declares",
+  HasTypeDeclaration: "DeclaresTypeAlias",
+  HasTypeSignature: "DeclaresTypeSignature",
+  HasVariable: "DeclaresVariable",
+  HasDirectRecursion: "DeclaresRecursively",
+};
 
 type MulangInspection = {
   inspection: string;
   binding: string;
+  args?: string[];
 };
 
+const NEGATION_PREFIXES = new Set(["Not", "Except"]);
+const SUFFIX_ARGS = new Set<TargetSuffix>(["like", "except"]);
+
 const isValidFormat = (inspection: any): inspection is MulangInspection =>
   typeof inspection === "object" &&
   "inspection" in inspection &&
@@ -17,22 +32,27 @@ const isValidFormat = (inspection: any): inspection is MulangInspection =>
  * @returns An array of InspectionRule objects.
  */
 export class MulangAdapter {
-  public translateMulangInspection(mulangInspection: any): InspectionRule {
+  public translateMulangInspection(mulangInspection: unknown): InspectionRule {
     if (!isValidFormat(mulangInspection))
       throw new Error(
-        `Skipping malformed Mulang inspection entry: ${mulangInspection}`
+        `Skipping malformed Mulang inspection entry: ${mulangInspection}`,
       );
 
-    const inspection: string[] = mulangInspection.inspection.split(":");
-    const expected: boolean =
-      inspection[0] !== "Not" && inspection[0] !== "Except";
-    const args: string[] = inspection.slice(expected ? 1 : 2);
+    // transforms Mulang v0 to v2
+    const { inspection, expected, binding, args } =
+      this.transformToV2(mulangInspection);
+
+    const { resolvedArgs, targetSuffix, matcher } =
+      this.retrieveArguments(args);
 
     return {
-      inspection: expected ? inspection[0] : inspection[1],
+      inspection,
       expected,
-      args,
-      binding: mulangInspection.binding,
+      binding,
+      args: resolvedArgs,
+      // these should not exist in the InspectionRule if they are undefined
+      ...(targetSuffix !== undefined && { targetSuffix }),
+      ...(matcher !== undefined && { matcher }),
     };
   }
 
@@ -64,4 +84,85 @@ export class MulangAdapter {
 
     return inspectionRules;
   }
+
+  private transformToV2(mulangInspection: MulangInspection) {
+    const parts = mulangInspection.inspection.split(":");
+    const {
+      expected,
+      inspection,
+      args: parsedArgs,
+    } = this.parseNegation(parts);
+    const args = mulangInspection.args ?? parsedArgs;
+    const v2 = this.applyV0ToV2(inspection, args, mulangInspection.binding);
+    return { expected, ...v2 };
+  }
+  private parseNegation(parts: string[]) {
+    const negated = NEGATION_PREFIXES.has(parts[0]);
+    return {
+      expected: !negated,
+      inspection: parts[negated ? 1 : 0],
+      args: parts.slice(negated ? 2 : 1),
+    };
+  }
+  private applyV0ToV2(inspection: string, args: string[], binding: string) {
+    if (inspection in declareMap)
+      return {
+        inspection: declareMap[inspection],
+        ...promoteBindingToTarget(args, binding),
+      };
+
+    if (inspection === "HasArity")
+      return {
+        inspection: `DeclaresComputationWithArity${args[0]}`,
+        ...promoteBindingToTarget([], binding),
+      };
+
+    if (inspection.startsWith("Has"))
+      return {
+        inspection: inspection.replace(/^Has(Usage)?/, (_, usage) =>
+          usage ? "Uses" : "Uses",
+        ),
+        args,
+        binding,
+      };
+
+    return { inspection, args, binding };
+  }
+
+  private retrieveArguments(args: string[]) {
+    const targetSuffix = args.find((a): a is TargetSuffix =>
+      SUFFIX_ARGS.has(a as TargetSuffix),
+    );
+
+    const matcherIndex = args.findIndex((a) => a.startsWith("With"));
+    const matcher =
+      matcherIndex !== -1
+        ? {
+            type: "with_" + args[matcherIndex].slice(4).toLowerCase(),
+            value: args[matcherIndex + 1],
+          }
+        : undefined;
+
+    const consumed = new Set([
+      ...(targetSuffix ? [targetSuffix] : []),
+      ...(matcherIndex !== -1
+        ? [args[matcherIndex], args[matcherIndex + 1]]
+        : []),
+    ]);
+
+    const resolvedArgs = args.filter((a) => !consumed.has(a));
+
+    return {
+      targetSuffix:
+        targetSuffix ??
+        (resolvedArgs.length > 0 ? ("named" as TargetSuffix) : undefined),
+      matcher,
+      resolvedArgs,
+    };
+  }
 }
+
+const promoteBindingToTarget = (args: string[], binding: string) => ({
+  args: binding && binding !== "*" ? [binding, ...args] : args,
+  binding: "*",
+});

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/analyzer/helpers.spec.ts

@@ -31,48 +31,54 @@ expectations:
 
     const yukigoExpectations =
       mulangAdapter.translateMulangExpectations(mulangExpectations);
+
     assert.deepEqual(yukigoExpectations, [
       {
-        inspection: "HasBinding",
-        binding: "squareList",
-        args: [],
+        inspection: "Declares",
+        binding: "*",
+        args: ["squareList"],
         expected: true,
+        targetSuffix: "named",
       },
       {
-        inspection: "HasLambdaExpression",
+        inspection: "UsesLambdaExpression",
         binding: "squareList",
         args: [],
         expected: true,
       },
       {
-        inspection: "HasArithmetic",
+        inspection: "UsesArithmetic",
         binding: "square",
         args: [],
         expected: true,
       },
       {
-        inspection: "HasBinding",
-        binding: "doble",
-        args: [],
+        inspection: "Declares",
+        binding: "*",
+        args: ["doble"],
         expected: false,
+        targetSuffix: "named",
       },
       {
         inspection: "Uses",
         binding: "square",
         args: ["x"],
         expected: true,
+        targetSuffix: "named",
       },
       {
         inspection: "Uses",
         binding: "squareList",
         args: ["map"],
         expected: true,
+        targetSuffix: "named",
       },
       {
         inspection: "Uses",
         binding: "squareList",
         args: ["map"],
         expected: false,
+        targetSuffix: "named",
       },
     ]);
   });

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(

package/tests/tester/Tester.spec.ts

@@ -12,7 +12,6 @@ import {
   SymbolPrimitive,
   ArithmeticBinaryOperation,
   Lambda,
-  Call,
   Application,
   VariablePattern,
 } from "yukigo-ast";

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

@@ -1,8 +0,0 @@
-import { EquationRuntime, PrimitiveValue, EnvStack } from "yukigo-ast";
-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 preloadDefinitions;
-    private static patternsMatch;
-    private static evaluateSequence;
-}