@nudojs/core 0.3.0 → 0.4.0

package/src/algebra/__tests__/generalize-memo.test.ts

@@ -1,285 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  generalizeFromAst,
-  resetGeneralizeMemo,
-  getGeneralizeMemoSize,
-  evictGeneralizeMemoForPaths,
-  formatAbs,
-  checkSource,
-  pTrue,
-  numLit,
-  numVar,
-  gtNum,
-  and,
-  v,
-  litValue,
-  strLit,
-  termToString,
-} from "../index.ts";
-
-const SRC = `
-function add(a, b) {
-  return a + b;
-}
-`;
-
-beforeEach(() => {
-  resetGeneralizeMemo();
-});
-
-describe("generalizeFromAst L0 memo", () => {
-  it("returns the same PolyFn instance for identical (source, name) queries", () => {
-    const a = generalizeFromAst("add", SRC);
-    const b = generalizeFromAst("add", SRC);
-    expect(a).toBeDefined();
-    expect(b).toBe(a);
-  });
-
-  it("misses when source content changes", () => {
-    const a = generalizeFromAst("add", SRC);
-    const b = generalizeFromAst("add", SRC + "\n// touch\n");
-    expect(a).toBeDefined();
-    expect(b).toBeDefined();
-    expect(b).not.toBe(a);
-  });
-
-  it("misses for a different function name", () => {
-    const src = `
-function add(a, b) { return a + b; }
-function sub(a, b) { return a - b; }
-`;
-    const a = generalizeFromAst("add", src);
-    const b = generalizeFromAst("sub", src);
-    expect(a).toBeDefined();
-    expect(b).toBeDefined();
-    expect(b).not.toBe(a);
-  });
-
-  it("caches undefined for missing functions", () => {
-    expect(generalizeFromAst("nope", SRC)).toBeUndefined();
-    expect(generalizeFromAst("nope", SRC)).toBeUndefined();
-  });
-
-  it("misses when label changes", () => {
-    const a = generalizeFromAst("add", SRC, { label: "A" });
-    const b = generalizeFromAst("add", SRC, { label: "B" });
-    expect(a).toBeDefined();
-    expect(b).toBeDefined();
-    expect(b).not.toBe(a);
-  });
-
-  it("misses when refine loadModule identity changes", () => {
-    const load1 = () => undefined;
-    const load2 = () => undefined;
-    const a = generalizeFromAst("add", SRC, { refine: { loadModule: load1, fromFile: "/t.js" } });
-    const b = generalizeFromAst("add", SRC, { refine: { loadModule: load2, fromFile: "/t.js" } });
-    expect(a).toBeDefined();
-    expect(b).toBeDefined();
-    expect(b).not.toBe(a);
-  });
-
-  it("hit is consistent with checkSource signatures", () => {
-    const g1 = generalizeFromAst("add", SRC);
-    const g2 = generalizeFromAst("add", SRC);
-    expect(formatAbs(g1!.symbolic)).toBe(formatAbs(g2!.symbolic));
-    const report = checkSource("t.js", SRC, pTrue, {});
-    expect(report.signatures.map((s) => s.name)).toContain("add");
-  });
-});
-
-describe("instantiate L1 memo", () => {
-  const SRC_SCALE = `
-function scale(x) {
-  return x + 1;
-}
-function pair(a, b) {
-  return { a, b };
-}
-`;
-
-  it("returns the same Abs instance for identical args + Φ", () => {
-    const g = generalizeFromAst("scale", SRC_SCALE)!;
-    const a1 = numVar("x", gtNum(v("x"), 0));
-    const phi = gtNum(v("x"), 0);
-    const r1 = g.instantiate([a1], phi);
-    const r2 = g.instantiate([numVar("x", gtNum(v("x"), 0))], phi);
-    expect(r2).toBe(r1);
-    expect(r1.term).toBeDefined();
-    expect(termToString(r1.term!)).toBe("(x + 1)");
-  });
-
-  it("hits for repeated literal args", () => {
-    const g = generalizeFromAst("scale", SRC_SCALE)!;
-    const r1 = g.instantiate([numLit(5)]);
-    const r2 = g.instantiate([numLit(5)]);
-    expect(litValue(r1)).toBe(6);
-    expect(r2).toBe(r1);
-  });
-
-  it("misses for different args", () => {
-    const g = generalizeFromAst("scale", SRC_SCALE)!;
-    const r1 = g.instantiate([numLit(5)]);
-    const r2 = g.instantiate([numLit(7)]);
-    expect(litValue(r1)).toBe(6);
-    expect(litValue(r2)).toBe(8);
-    expect(r2).not.toBe(r1);
-  });
-
-  it("misses when Φ differs under same arg shape", () => {
-    const g = generalizeFromAst("scale", SRC_SCALE)!;
-    const arg = numVar("x", gtNum(v("x"), 0));
-    const r1 = g.instantiate([arg], gtNum(v("x"), 0));
-    const r2 = g.instantiate([arg], pTrue);
-    // 结果可能同构，但键不同不得错误复用为同一对象（允许 equal，禁止错缓存）
-    expect(formatAbs(r1)).toBeTypeOf("string");
-    expect(formatAbs(r2)).toBeTypeOf("string");
-  });
-
-  it("shares L1 hits across L0 PolyFn identity", () => {
-    const g1 = generalizeFromAst("scale", SRC_SCALE)!;
-    const g2 = generalizeFromAst("scale", SRC_SCALE)!;
-    expect(g2).toBe(g1);
-    const r = g1.instantiate([numLit(2)]);
-    expect(g2.instantiate([numLit(2)])).toBe(r);
-  });
-
-  it("object args key by sorted slots (order-insensitive)", () => {
-    const g = generalizeFromAst("pair", SRC_SCALE)!;
-    const o1 = {
-      shape: {
-        k: "obj" as const,
-        slots: {
-          a: { value: numLit(1) },
-          b: { value: strLit("x") },
-        },
-      },
-      conf: "exact" as const,
-    };
-    const o2 = {
-      shape: {
-        k: "obj" as const,
-        slots: {
-          b: { value: strLit("x") },
-          a: { value: numLit(1) },
-        },
-      },
-      conf: "exact" as const,
-    };
-    const r1 = g.instantiate([o1, numLit(9)]);
-    // 第二参不同 → miss；同结构第一参应能命中同一对第一个参数的缓存路径
-    const r2 = g.instantiate([o2, numLit(9)]);
-    expect(formatAbs(r1)).toContain("a");
-    // 同键（slot 顺序无关）应返回同一缓存对象
-    expect(r2).toBe(r1);
-  });
-
-  it("resetGeneralizeMemo drops L0 and thus L1 tables", () => {
-    const g1 = generalizeFromAst("scale", SRC_SCALE)!;
-    const r1 = g1.instantiate([numLit(5)]);
-    resetGeneralizeMemo();
-    const g2 = generalizeFromAst("scale", SRC_SCALE)!;
-    expect(g2).not.toBe(g1);
-    const r2 = g2.instantiate([numLit(5)]);
-    expect(litValue(r2)).toBe(6);
-    expect(r2).not.toBe(r1);
-  });
-});
-
-describe("L2 α-equivalence + pred canonicalization", () => {
-  const SRC_ID = `
-function id(x) {
-  return x;
-}
-function inc(x) {
-  return x + 1;
-}
-`;
-
-  it("hits across renamed free vars and rewrites result vars", () => {
-    const g = generalizeFromAst("inc", SRC_ID)!;
-    const r1 = g.instantiate([numVar("x", gtNum(v("x"), 0))], gtNum(v("x"), 0));
-    const r2 = g.instantiate([numVar("y", gtNum(v("y"), 0))], gtNum(v("y"), 0));
-    expect(termToString(r1.term!)).toBe("(x + 1)");
-    expect(termToString(r2.term!)).toBe("(y + 1)");
-    // 不是同一对象（α 改写后的新 Abs），但结构同构
-    expect(r2).not.toBe(r1);
-    expect(formatAbs(r2).replace(/y/g, "x")).toBe(formatAbs(r1).replace(/x/g, "x"));
-  });
-
-  it("and-order does not cause miss", () => {
-    const g = generalizeFromAst("id", SRC_ID)!;
-    const ax = numVar("x", and(gtNum(v("x"), 0), gtNum(v("x"), 1)));
-    const phiA = and(gtNum(v("x"), 0), gtNum(v("x"), 1));
-    const phiB = and(gtNum(v("x"), 1), gtNum(v("x"), 0));
-    const r1 = g.instantiate([ax], phiA);
-    const r2 = g.instantiate([ax], phiB);
-    expect(formatAbs(r1)).toBe(formatAbs(r2));
-  });
-});
-
-describe("L3 deps fingerprint + LRU", () => {
-  const SRC_REFINE = `
-/// @nudo:import { positive } from "./shapes.nudo.js"
-
-/**
- * @nudo:refine x positive
- */
-function needsPositive(x) {
-  return x;
-}
-`;
-
-  it("misses L0 when imported nudo module content changes", () => {
-    let dep = "export const positive = number().gt(0);\n";
-    const loadModule = (spec: string) => (spec.includes("shapes") ? dep : undefined);
-    const refine = { loadModule, fromFile: "/proj/a.js" };
-    const g1 = generalizeFromAst("needsPositive", SRC_REFINE, { refine });
-    expect(g1).toBeDefined();
-    dep = "export const positive = number().gt(10);\n";
-    const g2 = generalizeFromAst("needsPositive", SRC_REFINE, { refine });
-    expect(g2).toBeDefined();
-    expect(g2).not.toBe(g1);
-  });
-
-  it("hits L0 when dep is unchanged", () => {
-    const loadModule = () => "export const positive = number().gt(0);\n";
-    const refine = { loadModule, fromFile: "/proj/a.js" };
-    const g1 = generalizeFromAst("needsPositive", SRC_REFINE, { refine });
-    const g2 = generalizeFromAst("needsPositive", SRC_REFINE, { refine });
-    expect(g2).toBe(g1);
-  });
-
-  it("tracks memo size and can reset", () => {
-    resetGeneralizeMemo();
-    expect(getGeneralizeMemoSize()).toBe(0);
-    generalizeFromAst("add", SRC);
-    expect(getGeneralizeMemoSize()).toBeGreaterThan(0);
-    resetGeneralizeMemo();
-    expect(getGeneralizeMemoSize()).toBe(0);
-  });
-
-  it("evictGeneralizeMemoForPaths drops only dependents of that dep", () => {
-    resetGeneralizeMemo();
-    const loadModule = () => "export const positive = number().gt(0);\n";
-    const refine = { loadModule, fromFile: "/proj/a.js" };
-    const g1 = generalizeFromAst("needsPositive", SRC_REFINE, { refine });
-    const gOther = generalizeFromAst("add", SRC);
-    const sizeAfter = getGeneralizeMemoSize();
-    const n = evictGeneralizeMemoForPaths(["/proj/shapes.nudo.js"]);
-    expect(n).toBeGreaterThan(0);
-    expect(getGeneralizeMemoSize()).toBeLessThan(sizeAfter);
-    // 无关函数仍在
-    expect(generalizeFromAst("add", SRC)).toBe(gOther);
-    // 依赖被逐出 → 重新 generalize 得到新 PolyFn
-    const g2 = generalizeFromAst("needsPositive", SRC_REFINE, { refine });
-    expect(g2).not.toBe(g1);
-    expect(g2).toBeDefined();
-  });
-
-  it("evict is a no-op for unknown paths", () => {
-    resetGeneralizeMemo();
-    generalizeFromAst("add", SRC);
-    expect(evictGeneralizeMemoForPaths(["/nope/missing.nudo.js"])).toBe(0);
-    expect(getGeneralizeMemoSize()).toBeGreaterThan(0);
-  });
-});

package/src/algebra/__tests__/generalize.test.ts

@@ -1,113 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  generalizeFromAst,
-  generalizeAll,
-  numLit,
-  numVar,
-  gtNum,
-  v,
-  litValue,
-  termToString,
-  formatAbs,
-} from "../index.ts";
-
-const SRC = `
-const add = (a, b) => a + b;
-function scale(x) {
-  return add(x, 1);
-}
-function twice(x) {
-  const c = add(x, 1);
-  return add(c, 1);
-}
-function id(x) { return x; }
-function pair(a, b) { return { a, b }; }
-`;
-
-describe("generalize", () => {
-  it("scale generalizes to term = A1+1", () => {
-    const g = generalizeFromAst("scale", SRC);
-    expect(g).toBeDefined();
-    if (!g) return;
-    expect(g.params).toEqual(["x"]);
-    expect(g.typeParams.length).toBe(1);
-    expect(g.symbolic.term).toBeDefined();
-    expect(termToString(g.symbolic.term!)).toBe("(A1 + 1)");
-  });
-
-  it("instantiate scale with x>0 gives (x+1)>1", () => {
-    const g = generalizeFromAst("scale", SRC);
-    expect(g).toBeDefined();
-    if (!g) return;
-    const phi = gtNum(v("x"), 0);
-    const r = g.instantiate([numVar("x", gtNum(v("x"), 0))], phi);
-    expect(termToString(r.term!)).toBe("(x + 1)");
-    expect(r.pred!.op).toBe("gt");
-  });
-
-  it("instantiate scale with literal 5 gives 6", () => {
-    const g = generalizeFromAst("scale", SRC);
-    if (!g) return;
-    const r = g.instantiate([numLit(5)]);
-    expect(litValue(r)).toBe(6);
-    expect(r.conf).toBe("exact");
-  });
-
-  it("id is identity: term stays A1", () => {
-    const g = generalizeFromAst("id", SRC);
-    if (!g) return;
-    expect(g.symbolic.term?.op).toBe("var");
-    if (g.symbolic.term?.op === "var") {
-      expect(g.symbolic.term.id).toBe("A1");
-    }
-  });
-
-  it("twice nests to (A1+1)+1", () => {
-    const g = generalizeFromAst("twice", SRC);
-    if (!g) return;
-    const ts = termToString(g.symbolic.term!);
-    expect(ts === "((A1 + 1) + 1)" || ts === "(A1 + 2)").toBe(true);
-  });
-
-  it("generalizeAll finds all functions", () => {
-    const all = generalizeAll(SRC);
-    const names = all.map((g) => g.name).sort();
-    expect(names).toContain("add");
-    expect(names).toContain("scale");
-    expect(names).toContain("twice");
-    expect(names).toContain("id");
-  });
-
-  it("display mentions type params", () => {
-    const g = generalizeFromAst("scale", SRC);
-    if (!g) return;
-    expect(g.display).toContain("scale");
-    expect(g.display).toContain("A1");
-  });
-
-  it("attaches @nudo:refine to entry param Abs", () => {
-    const src = `
-/// @nudo:import { positive } from "./x.nudo.js"
-/**
- * @nudo:refine x positive
- */
-function scale(x) { return x + 1; }
-function bare(x) { return x + 1; }
-`;
-    const loadModule = () => `export const positive = number().gt(0);`;
-    const g = generalizeFromAst("scale", src, {
-      refine: { loadModule, fromFile: "/t/a.js" },
-    });
-    expect(g).toBeDefined();
-    expect(g!.typeParams[0]!.value.shape).toEqual({ k: "prim", type: "number" });
-    expect(g!.entryReqs?.[0]?.param).toBe("x");
-    expect(g!.display).toContain("x > 0");
-    expect(formatAbs(g!.symbolic)).toContain("number");
-
-    const b = generalizeFromAst("bare", src, {
-      refine: { loadModule, fromFile: "/t/a.js" },
-    });
-    expect(b!.typeParams[0]!.value.shape.k).toBe("any");
-    expect(b!.display).toContain("number | string");
-  });
-});

package/src/algebra/__tests__/hash-source.test.ts

@@ -1,19 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { hashSource, resetHashSourceCache } from "../hash-source.ts";
-
-describe("hashSource", () => {
-  it("is stable for identical input and differs on length/content", () => {
-    resetHashSourceCache();
-    const a = hashSource("hello world");
-    expect(hashSource("hello world")).toBe(a);
-    expect(hashSource("hello world!")).not.toBe(a);
-    // pure 32-bit FNV can collide on crafted pairs; length+second mix should not
-    expect(hashSource("a")).not.toBe(hashSource("b"));
-  });
-
-  it("includes length so truncated prefixes do not alias", () => {
-    resetHashSourceCache();
-    // classic FNV pitfalls often involve short suffixes; length disambiguates
-    expect(hashSource("abc")).not.toBe(hashSource("abcabc"));
-  });
-});

package/src/algebra/__tests__/hof.test.ts

@@ -1,80 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  analyzeFn,
-  numLit,
-  strLit,
-  numVar,
-  gtNum,
-  v,
-  litValue,
-  termToString,
-  formatShape,
-  abs,
-  unknown,
-} from "../index.ts";
-
-describe("HOF map/reduce from real source", () => {
-  it("map doubles literals: [1,2,3].map(x=>x*2) → number[] with joined elem", () => {
-    const src = `
-      function doubleAll(xs) {
-        return xs.map((x) => x * 2);
-      }
-    `;
-    // 实参数组：arr(number)
-    const arr = abs({ k: "arr", element: numLit(1) }, undefined, undefined, "exact");
-    const r = analyzeFn(src, "doubleAll", [arr]);
-    expect(r.shape.k).toBe("arr");
-    if (r.shape.k !== "arr") return;
-    // x=1, x*2=2
-    expect(litValue(r.shape.element)).toBe(2);
-  });
-
-  it("map on symbolic element: Arr(number) map x=>x+1 under Φ elem>0", () => {
-    // 元素带约束的数组：用 numVar 作为 element 的 term/pred
-    const elem = {
-      shape: { k: "prim" as const, type: "number" as const },
-      term: { op: "var" as const, id: "e" },
-      pred: { op: "gt" as const, a: { op: "var" as const, id: "e" }, b: { op: "lit" as const, value: 0 } },
-      conf: "path" as const,
-    };
-    const arr = abs({ k: "arr", element: elem }, undefined, undefined, "path");
-    const src = `
-      function incAll(xs) {
-        return xs.map((x) => x + 1);
-      }
-    `;
-    const r = analyzeFn(src, "incAll", [arr]);
-    expect(r.shape.k).toBe("arr");
-    if (r.shape.k !== "arr") return;
-    const el = r.shape.element;
-    expect(termToString(el.term!)).toBe("(e + 1)");
-    expect(el.pred!.op).toBe("gt");
-  });
-
-  it("reduce sum of literals: [1,2,3].reduce((a,n)=>a+n,0) → 6", () => {
-    const src = `
-      function sum(xs) {
-        return xs.reduce((acc, n) => acc + n, 0);
-      }
-    `;
-    const arr = abs({ k: "arr", element: numLit(1) }, undefined, undefined, "exact");
-    // 用字面量元素 1 反复加不够 —— 用 tuple 语义：我们用 arr(number) 时元素是 1
-    // 更好：传 tuple
-    // Phase A：reduce 对 arr(element) 做不动点：0+1=1, 1+1=2, ... 会收敛到 number
-    const r = analyzeFn(src, "sum", [arr]);
-    // 0+1=1 exact first iter; join(0,1) 丢 term → number path
-    // 或者若 first next=1, join(0,1) → number
-    expect(r.shape).toEqual({ k: "prim", type: "number" });
-  });
-
-  it("filter preserves element type", () => {
-    const src = `
-      function keep(xs) {
-        return xs.filter((x) => x > 0);
-      }
-    `;
-    const arr = abs({ k: "arr", element: numLit(5) }, undefined, undefined, "exact");
-    const r = analyzeFn(src, "keep", [arr]);
-    expect(r.shape.k).toBe("arr");
-  });
-});

package/src/algebra/__tests__/inlay.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { collectAbsInlays } from "../inlay.ts";
-
-describe("collectAbsInlays", () => {
-  it("shows param constraint and return Abs", () => {
-    const src = `
-function needsPositive(x) {
-  if (x > 0) return x;
-  return 0;
-}
-`;
-    const inlays = collectAbsInlays(src);
-    expect(inlays.length).toBeGreaterThan(0);
-    const param = inlays.find((i) => i.kind === "parameter");
-    expect(param).toBeDefined();
-    expect(param!.label).toContain(">");
-    const ret = inlays.find((i) => i.kind === "type");
-    expect(ret).toBeDefined();
-    expect(ret!.label).toContain(":");
-  });
-
-  it("shows scale return term", () => {
-    const src = `function scale(x) { return x + 1; }\n`;
-    const inlays = collectAbsInlays(src);
-    const ret = inlays.find((i) => i.kind === "type");
-    expect(ret).toBeDefined();
-    // generalize 后是符号项 A1
-    expect(ret!.label).toContain("A1 + 1");
-  });
-});

package/src/algebra/__tests__/language.test.ts

@@ -1,77 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  analyzeFn,
-  numLit,
-  litValue,
-} from "../index.ts";
-
-describe("language: class / instanceof / async", () => {
-  it("class + new → brand with methods", () => {
-    const src = `
-class Point {
-  constructor(x) { this.x = x; }
-  dist() { return this.x; }
-}
-function main() {
-  const p = new Point(3);
-  return p;
-}
-`;
-    const r = analyzeFn(src, "main", []);
-    expect(r.shape.k).toBe("brand");
-    if (r.shape.k === "brand") {
-      expect(r.shape.name).toBe("Point");
-    }
-  });
-
-  it("instanceof brand name → true/false exact", () => {
-    const src = `
-class Point { dist() { return 1; } }
-class Other { dist() { return 2; } }
-function check() {
-  const p = new Point();
-  return p instanceof Point;
-}
-function checkOther() {
-  const p = new Point();
-  return p instanceof Other;
-}
-`;
-    const r1 = analyzeFn(src, "check", []);
-    expect(litValue(r1)).toBe(true);
-    expect(r1.conf).toBe("exact");
-    const r2 = analyzeFn(src, "checkOther", []);
-    expect(litValue(r2)).toBe(false);
-  });
-
-  it("async function returns eff promise", () => {
-    const src = `
-async function load(id) {
-  return id + 1;
-}
-`;
-    const r = analyzeFn(src, "load", [numLit(5)]);
-    expect(r.shape.k).toBe("eff");
-    if (r.shape.k === "eff") {
-      expect(r.shape.eff).toBe("promise");
-      expect(litValue(r.shape.inner)).toBe(6);
-    }
-  });
-
-  it("await unwraps promise", () => {
-    const src = `
-async function load(id) {
-  return id + 1;
-}
-async function twice(id) {
-  const a = await load(id);
-  return a + 1;
-}
-`;
-    const r = analyzeFn(src, "twice", [numLit(5)]);
-    expect(r.shape.k).toBe("eff");
-    if (r.shape.k === "eff") {
-      expect(litValue(r.shape.inner)).toBe(7);
-    }
-  });
-});