@nudojs/core 0.1.0 → 0.3.0

package/src/algebra/surface.ts

@@ -0,0 +1,206 @@
+/**
+ * 语言表面运算（仍在 Abs 上）：typeof / 一元- / ! / nullish 相等。
+ * 类型即计算——一元与控制流判定与二元算术同一运算域。
+ */
+
+import type { Abs, Shape, Confidence } from "./abs.ts";
+import { abs, litValue, confJoin, num, bool, boolLit, strLit } from "./abs.ts";
+import type { Term } from "./term.ts";
+import { lit, simplifyTerm, app } from "./term.ts";
+import type { Pred } from "./pred.ts";
+import {
+  pTrue,
+  gt,
+  ge,
+  lt,
+  le,
+  and,
+  type Phi,
+} from "./pred.ts";
+import { implies } from "./pred.ts";
+
+/** JS typeof：结果域永远是 string */
+export function typeofAbs(a: Abs): Abs {
+  const v = litValue(a);
+  if (v === null) return strLit("object");
+  // lit(undefined) 与「无 lit」在 litValue 上都是 undefined，须看 term
+  if (a.term?.op === "lit" && a.term.value === undefined) {
+    return strLit("undefined");
+  }
+  if (a.shape.k === "any" || a.shape.k === "unknown") {
+    // any/unknown：typeof 只能确定是 string，具体名未知
+    return abs({ k: "prim", type: "string" }, undefined, undefined, "partial");
+  }
+  if (a.shape.k === "sum") {
+    const names = [...new Set(a.shape.members.map((m) => typeofName(m.shape)))];
+    if (names.length === 1 && names[0] !== "unknown") return strLit(names[0]!);
+    return abs({ k: "prim", type: "string" }, undefined, undefined, "partial");
+  }
+  return strLit(typeofName(a.shape));
+}
+
+function typeofName(s: Shape): string {
+  switch (s.k) {
+    case "never":
+      return "undefined";
+    case "any":
+      return "unknown";
+    case "unknown":
+      return "unknown";
+    case "prim":
+      return s.type;
+    case "obj":
+    case "arr":
+    case "tuple":
+    case "brand":
+      return "object";
+    case "fn":
+      return "function";
+    case "eff":
+      return "object";
+    case "sum": {
+      const names = [...new Set(s.members.map((m) => typeofName(m.shape)))];
+      if (names.length === 1) return names[0]!;
+      return "unknown";
+    }
+    default:
+      return "unknown";
+  }
+}
+
+/** 一元负号：字面量折叠；符号数翻转不等式 */
+export function negAbs(a: Abs, _phi: Phi = pTrue): Abs {
+  const v = litValue(a);
+  if (typeof v === "number") return numLitAbs(-v);
+  if (a.shape.k === "prim" && a.shape.type === "number") {
+    if (!a.term) {
+      return abs(num().shape, undefined, undefined, confJoin(a.conf, "widened"));
+    }
+    const term = simplifyTerm(app("-", [a.term]));
+    // -x：lo/hi 互换并取负
+    const facts: Pred[] = [];
+    // 从自身 pred 推：若 x > c ⇒ -x < -c
+    if (a.pred && a.pred.op !== "true" && a.term) {
+      flipBounds(a.pred, a.term, term, facts);
+    }
+    return abs(
+      num().shape,
+      term,
+      facts.length ? and(...facts) : undefined,
+      confJoin(a.conf, "path"),
+    );
+  }
+  return abs({ k: "unknown" }, undefined, undefined, "partial");
+}
+
+function numLitAbs(n: number): Abs {
+  return abs(num().shape, lit(n), pTrue, "exact");
+}
+
+function flipBounds(pred: Pred, src: Term, dst: Term, out: Pred[]): void {
+  const apply = (p: Pred): void => {
+    if (p.op === "and") {
+      p.args.forEach(apply);
+      return;
+    }
+    if (
+      p.op !== "gt" && p.op !== "ge" && p.op !== "lt" && p.op !== "le"
+    ) {
+      return;
+    }
+    if (termKey(p.a) !== termKey(src)) return;
+    if (p.b.op !== "lit" || typeof p.b.value !== "number") return;
+    const n = p.b.value;
+    // x > n ⇒ -x < -n；x ≥ n ⇒ -x ≤ -n；对称
+    if (p.op === "gt") out.push(lt(dst, lit(-n)));
+    else if (p.op === "ge") out.push(le(dst, lit(-n)));
+    else if (p.op === "lt") out.push(gt(dst, lit(-n)));
+    else if (p.op === "le") out.push(ge(dst, lit(-n)));
+  };
+  apply(pred);
+}
+
+function termKey(t: Term): string {
+  if (t.op === "lit") return `lit:${JSON.stringify(t.value)}`;
+  if (t.op === "var") return `var:${t.id}`;
+  return `app:${t.fn}`;
+}
+
+/** 逻辑非 */
+export function notAbs(a: Abs): Abs {
+  // 字面量（含 null/undefined/0/""）：直接折叠
+  if (a.term?.op === "lit") {
+    return boolLit(!a.term.value);
+  }
+  if (a.shape.k === "prim" && a.shape.type === "boolean") {
+    return abs(bool().shape, undefined, undefined, confJoin(a.conf, "widened"));
+  }
+  // 对象恒真
+  if (isDefinitelyTruthyShape(a.shape)) return boolLit(false);
+  if (isDefinitelyFalsyShape(a.shape)) return boolLit(true);
+  return abs(bool().shape, undefined, undefined, "partial");
+}
+
+function isDefinitelyTruthyShape(s: Shape): boolean {
+  switch (s.k) {
+    case "obj":
+    case "arr":
+    case "tuple":
+    case "fn":
+    case "brand":
+    case "eff":
+      return true;
+    case "prim":
+      return s.type === "symbol" || s.type === "bigint";
+    default:
+      return false;
+  }
+}
+
+function isDefinitelyFalsyShape(s: Shape): boolean {
+  return s.k === "never";
+}
+
+/** 该 shape 在 JS 上一定不是 null/undefined */
+export function definitelyNotNullishShape(s: Shape): boolean {
+  switch (s.k) {
+    case "prim":
+    case "obj":
+    case "arr":
+    case "tuple":
+    case "fn":
+    case "brand":
+    case "eff":
+      return true;
+    case "sum":
+      return s.members.every((m) => definitelyNotNullishShape(m.shape));
+    default:
+      return false;
+  }
+}
+
+export function isNullishLitAbs(a: Abs): boolean {
+  const v = litValue(a);
+  if (v === null || v === undefined) return true;
+  // shape 层：无 lit 的 unknown 不判 nullish
+  return false;
+}
+
+/**
+ * 严格相等（Abs）：双字面量折叠；nullish 与 definitely-not-nullish → false。
+ * 返回 undefined = 无法判定（交给 boolean + 调用方）。
+ */
+export function strictEqAbs(a: Abs, b: Abs): boolean | undefined {
+  const va = litValue(a);
+  const vb = litValue(b);
+  if (va !== undefined && vb !== undefined) return va === vb;
+  const aNullish = va === null || (a.term?.op === "lit" && a.term.value === undefined);
+  const bNullish = vb === null || (b.term?.op === "lit" && b.term.value === undefined);
+  if (bNullish && definitelyNotNullishShape(a.shape)) return false;
+  if (aNullish && definitelyNotNullishShape(b.shape)) return false;
+  // 同 var 恒等
+  if (a.term && b.term && a.term.op === "var" && b.term.op === "var" && a.term.id === b.term.id) {
+    return true;
+  }
+  return undefined;
+}

package/src/algebra/template.ts

@@ -0,0 +1,143 @@
+/**
+ * Template string 拼接（代数侧）。
+ * 表示：prim(string) + refinement.meta.templateParts = Abs[]
+ * 与 core 的 createTemplate 对齐，使 `"x" + string + "!"` 得到 template refined。
+ */
+
+import type { Abs } from "./abs.ts";
+import { abs, litValue } from "./abs.ts";
+import { lit, termToString, type Term } from "./term.ts";
+import { pTrue, type Pred } from "./pred.ts";
+
+export type TemplateMeta = {
+  templateParts: Abs[];
+};
+
+function isStrLit(a: Abs): a is Abs & { term: { op: "lit"; value: string } } {
+  return (
+    a.shape.k === "prim" &&
+    a.shape.type === "string" &&
+    a.term?.op === "lit" &&
+    typeof a.term.value === "string"
+  );
+}
+
+function isStrPrim(a: Abs): boolean {
+  return a.shape.k === "prim" && a.shape.type === "string";
+}
+
+function isTemplateAbs(a: Abs): boolean {
+  return (
+    a.shape.k === "prim" &&
+    a.shape.type === "string" &&
+    !!a.pred &&
+    (a.pred as { name?: string }).name?.startsWith("`") === true &&
+    Array.isArray(((a.pred as { meta?: TemplateMeta }).meta)?.templateParts)
+  );
+}
+
+/** 从 Abs 提取 template parts（已是 template 则展开，否则 [self]） */
+export function templatePartsOf(a: Abs): Abs[] {
+  if (isTemplateAbs(a)) {
+    const meta = (a.pred as unknown as { meta: TemplateMeta }).meta;
+    return meta.templateParts;
+  }
+  return [a];
+}
+
+/**
+ * 合并相邻字面量；纯字面量折叠为 lit；单 string prim → prim。
+ */
+function normalizeParts(parts: Abs[]): Abs[] {
+  const out: Abs[] = [];
+  for (const p of parts) {
+    const last = out[out.length - 1];
+    if (last && isStrLit(last) && isStrLit(p)) {
+      out[out.length - 1] = abs(
+        { k: "prim", type: "string" },
+        lit(String(litValue(last)) + String(litValue(p))),
+        undefined,
+        "exact",
+      );
+    } else {
+      out.push(p);
+    }
+  }
+  return out;
+}
+
+function formatTemplateName(parts: Abs[]): string {
+  const inner = parts
+    .map((p) => {
+      if (isStrLit(p)) return String(litValue(p));
+      return `\${${p.term ? termToString(p.term) : "string"}}`;
+    })
+    .join("");
+  return `\`${inner}\``;
+}
+
+/**
+ * 构造 template Abs。
+ * - 全字面量 → exact lit
+ * - 单 string prim → prim
+ * - 否则 prim(string) + pred(name=template, meta.templateParts)
+ */
+export function createTemplateAbs(parts: Abs[]): Abs {
+  const normalized = normalizeParts(parts);
+  if (normalized.length === 1) {
+    const only = normalized[0]!;
+    if (isStrLit(only)) return only;
+    if (isStrPrim(only) && !isTemplateAbs(only)) return only;
+  }
+  const name = formatTemplateName(normalized);
+  // abs() 会丢弃 op==="true" 的 pred；直接构造以保留 template meta
+  const predObj = {
+    op: "true",
+    name,
+    meta: { templateParts: normalized } satisfies TemplateMeta,
+  } as unknown as Pred;
+
+  return {
+    shape: { k: "prim", type: "string" },
+    term: undefined,
+    pred: predObj,
+    conf: "path",
+  };
+}
+
+export function isTemplateLike(a: Abs): boolean {
+  return isTemplateAbs(a);
+}
+
+/** 字符串拼接：字面量折叠 + template parts 合并 */
+export function concatString(a: Abs, b: Abs): Abs {
+  // 双字面量
+  if (isStrLit(a) && isStrLit(b)) {
+    return abs(
+      { k: "prim", type: "string" },
+      lit(String(litValue(a)) + String(litValue(b))),
+      undefined,
+      "exact",
+    );
+  }
+  // 至少一侧是 string（含 template / prim / 可 stringify 字面量）
+  const aParts = coerceToStringParts(a);
+  const bParts = coerceToStringParts(b);
+  if (!aParts || !bParts) return abs({ k: "unknown" }, undefined, undefined, "partial");
+  return createTemplateAbs([...aParts, ...bParts]);
+}
+
+function coerceToStringParts(a: Abs): Abs[] | undefined {
+  if (isTemplateAbs(a) || isStrPrim(a)) return templatePartsOf(a);
+  if (isStrLit(a)) return [a];
+  // 数值/布尔字面量：JS ToPrimitive 拼接
+  const lv = litValue(a);
+  if (typeof lv === "number" || typeof lv === "boolean") {
+    return [abs({ k: "prim", type: "string" }, lit(String(lv)), undefined, "exact")];
+  }
+  if (a.shape.k === "prim" && a.shape.type === "number") {
+    // abstract number → `${number}` part
+    return [a];
+  }
+  return undefined;
+}

package/src/algebra/term.ts

@@ -0,0 +1,119 @@
+/** 项（Term）：抽象值的身份。字面量是项的特例。 */
+
+export type LiteralValue = string | number | boolean | null | undefined;
+
+export type Term =
+  | { op: "lit"; value: LiteralValue }
+  | { op: "var"; id: string }
+  | { op: "app"; fn: string; args: Term[] };
+
+export const lit = (value: LiteralValue): Term => ({
+  op: "lit",
+  // -0 与 0 在约束语义上等价，统一为 +0
+  value: typeof value === "number" && value === 0 ? 0 : value,
+});
+export const v = (id: string): Term => ({ op: "var", id });
+export const app = (fn: string, args: Term[]): Term => ({ op: "app", fn, args });
+
+export function termEquals(a: Term, b: Term): boolean {
+  if (a.op !== b.op) return false;
+  if (a.op === "lit" && b.op === "lit") return a.value === b.value;
+  if (a.op === "var" && b.op === "var") return a.id === b.id;
+  if (a.op === "app" && b.op === "app") {
+    return (
+      a.fn === b.fn &&
+      a.args.length === b.args.length &&
+      a.args.every((x, i) => termEquals(x, b.args[i]!))
+    );
+  }
+  return false;
+}
+
+export function termToString(t: Term): string {
+  if (t.op === "lit") {
+    return typeof t.value === "string" ? JSON.stringify(t.value) : String(t.value);
+  }
+  if (t.op === "var") return t.id;
+  // 字段访问：get(u, "id") → u.id
+  if (t.op === "app" && t.fn === "get" && t.args.length === 2) {
+    const obj = termToString(t.args[0]!);
+    const key = t.args[1]!;
+    if (key.op === "lit" && typeof key.value === "string") {
+      return `${obj}.${key.value}`;
+    }
+  }
+  if (t.fn === "+" && t.args.length === 2) {
+    return `(${termToString(t.args[0]!)} + ${termToString(t.args[1]!)})`;
+  }
+  if (t.fn === "-" && t.args.length === 2) {
+    return `(${termToString(t.args[0]!)} - ${termToString(t.args[1]!)})`;
+  }
+  if (t.fn === "*" && t.args.length === 2) {
+    return `(${termToString(t.args[0]!)} * ${termToString(t.args[1]!)})`;
+  }
+  return `${t.fn}(${t.args.map(termToString).join(", ")})`;
+}
+
+/** 常量折叠 + 简单代数化简 */
+export function simplifyTerm(t: Term): Term {
+  if (t.op !== "app") return t;
+  const args = t.args.map(simplifyTerm);
+  const fn = t.fn;
+
+  if (args.every((a) => a.op === "lit")) {
+    const xs = args.map((a) => (a as { value: LiteralValue }).value);
+    const folded = foldLiterals(fn, xs);
+    if (folded !== undefined) return lit(folded);
+  }
+
+  // x + 0 = x, 0 + x = x
+  if (fn === "+" && args.length === 2) {
+    const [a, b] = args as [Term, Term];
+    if (a.op === "lit" && a.value === 0) return b;
+    if (b.op === "lit" && b.value === 0) return a;
+  }
+  // x * 1 = x, 1 * x = x; x * 0 = 0
+  if (fn === "*" && args.length === 2) {
+    const [a, b] = args as [Term, Term];
+    if (a.op === "lit" && a.value === 1) return b;
+    if (b.op === "lit" && b.value === 1) return a;
+    if (
+      (a.op === "lit" && a.value === 0) ||
+      (b.op === "lit" && b.value === 0)
+    ) {
+      return lit(0);
+    }
+  }
+  // x - 0 = x
+  if (fn === "-" && args.length === 2) {
+    const [a, b] = args as [Term, Term];
+    if (b.op === "lit" && b.value === 0) return a;
+  }
+
+  return app(fn, args);
+}
+
+function foldLiterals(fn: string, xs: LiteralValue[]): LiteralValue | undefined {
+  if (fn === "+" && xs.length === 2) {
+    const [a, b] = xs as [number | string, number | string];
+    if (typeof a === "number" && typeof b === "number") return a + b;
+    if (typeof a === "string" || typeof b === "string") return String(a) + String(b);
+    return undefined;
+  }
+  if (fn === "-" && xs.length === 2) {
+    const [a, b] = xs as [number, number];
+    if (typeof a === "number" && typeof b === "number") return a - b;
+    return undefined;
+  }
+  if (fn === "*" && xs.length === 2) {
+    const [a, b] = xs as [number, number];
+    if (typeof a === "number" && typeof b === "number") return a * b;
+    return undefined;
+  }
+  if (fn === "neg" && xs.length === 1) {
+    const a = xs[0];
+    if (typeof a === "number") return -a;
+    return undefined;
+  }
+  return undefined;
+}

package/src/environment.ts

@@ -5,6 +5,7 @@ export type Environment = {
   bind(name: string, value: TypeValue): Environment;
   update(name: string, value: TypeValue): boolean;
   extend(bindings: Record<string, TypeValue>): Environment;
+  fork(): Environment;
   has(name: string): boolean;
   snapshot(): Environment;
   getOwnBindings(): Record<string, TypeValue>;
@@ -46,6 +47,10 @@ export function createEnvironment(
       return createEnvironment(env, childMap);
     },
 
+    fork() {
+      return createEnvironment(env);
+    },
+
     has(name) {
       return store.has(name) || (parent?.has(name) ?? false);
     },

package/src/index.ts

@@ -1,22 +1,73 @@
+/**
+ * @nudojs/core — 唯一类型系统。
+ *
+ * 内涵（algebra）：Abs = shape × term × pred × conf，类型即计算。
+ * 外延（TypeValue）：评估 IR——环境绑定、dts/lsp/序列化消费的投影格式，
+ * 不是平行类型系统。Abs ⇄ TypeValue 经 bridge 有损投影。
+ */
+
+// --- 评估 IR（TypeValue）---
 export {
   type TypeValue,
   type LiteralValue,
+  type Refinement,
+  type FunctionSignature,
+  type SigImpl,
   T,
   typeValueEquals,
   simplifyUnion,
   widenLiteral,
+  collapseLiteralUnion,
   isSubtypeOf,
   typeValueToString,
   narrowType,
   subtractType,
   getPrimitiveTypeOf,
+  getRefinedBase,
   deepCloneTypeValue,
   mergeObjectProperties,
+  isFnSig,
+  getFnSig,
 } from "./type-value.ts";
 
-export { Ops, applyBinaryOp } from "./ops.ts";
+/** 外延二元/一元运算：代数未覆盖的语言表面（/ % === typeof 等） */
+export { Ops, applyBinaryOp, dispatchBinaryOp, dispatchMethod, dispatchProperty } from "./ops.ts";
 
 export {
   type Environment,
   createEnvironment,
 } from "./environment.ts";
+
+export {
+  createTemplate,
+  isTemplate,
+  getTemplateParts,
+  concatTemplates,
+  getKnownPrefix,
+  getKnownSuffix,
+} from "./refinements/template.ts";
+
+export {
+  createRange,
+  isRange,
+  getRangeMeta,
+  type RangeMeta,
+} from "./refinements/range.ts";
+
+export {
+  type MockHelper,
+  stub,
+  spy,
+  mock,
+  mockHelperToTypeValue,
+} from "./mock-helpers.ts";
+
+export { stripTypes } from "./strip-types.ts";
+export {
+  parseSource,
+  resetParseSourceCache,
+  getParseSourceCacheSize,
+} from "./algebra/parse-source.ts";
+
+// --- 内涵：类型即计算 ---
+export * from "./algebra/index.ts";