@stevenvo780/st-lang 4.3.0 → 4.5.0

package/dist/refinement-types/subtype.js

@@ -0,0 +1,39 @@
+"use strict";
+// ============================================================
+// Refinement types — Subtipado por implicación
+// ============================================================
+//
+// Definición:
+//   { x : B | P(x) } <: { y : B | Q(y) }
+//     ⟺  B = B'  ∧  ∀x. P(x) ⇒ Q[x/y]
+//
+// Para tipos arrow se aplica contravarianza en el parámetro y
+// covarianza en el resultado, como en sistemas refinados estándar.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSubtype = isSubtype;
+const solver_1 = require("./solver");
+const predicate_1 = require("./predicate");
+/**
+ * isSubtype — devuelve true si T1 <: T2 bajo las suposiciones del contexto.
+ *
+ * - Para tipos base iguales: chequea P(x) ⇒ Q(x) renombrando el binding.
+ * - Para arrows: contravarianza en `from`, covarianza en `to`.
+ */
+function isSubtype(t1, t2, opts = {}) {
+    return isSubBase(t1.base, t2.base, opts) && isSubRefinement(t1, t2, opts);
+}
+function isSubBase(b1, b2, opts) {
+    if (typeof b1 === 'string' || typeof b2 === 'string')
+        return b1 === b2;
+    // arrow: contravariant en from, covariant en to
+    return isSubtype(b2.from, b1.from, opts) && isSubtype(b1.to, b2.to, opts);
+}
+function isSubRefinement(t1, t2, opts) {
+    // Renombramos el binding de t2 al de t1 para chequear P(x) ⇒ Q(x).
+    const sharedName = t1.binding;
+    const p = t1.predicate.trim() === '' ? 'true' : t1.predicate;
+    const q = (0, predicate_1.renameVar)(t2.predicate.trim() === '' ? 'true' : t2.predicate, t2.binding, sharedName);
+    const premises = [p, ...(opts.extraAssumptions ?? [])];
+    return (0, solver_1.implies)(premises, q, opts);
+}
+//# sourceMappingURL=subtype.js.map

package/dist/refinement-types/subtype.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtype.js","sourceRoot":"","sources":["../../src/refinement-types/subtype.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,+CAA+C;AAC/C,+DAA+D;AAC/D,EAAE;AACF,cAAc;AACd,yCAAyC;AACzC,sCAAsC;AACtC,EAAE;AACF,8DAA8D;AAC9D,mEAAmE;;AAiBnE,8BAEC;AAhBD,qCAAoD;AACpD,2CAAwC;AAOxC;;;;;GAKG;AACH,SAAgB,SAAS,CAAC,EAAW,EAAE,EAAW,EAAE,OAAoB,EAAE;IACxE,OAAO,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,eAAe,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;AAC5E,CAAC;AAED,SAAS,SAAS,CAAC,EAAY,EAAE,EAAY,EAAE,IAAiB;IAC9D,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,OAAO,EAAE,KAAK,QAAQ;QAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IACvE,gDAAgD;IAChD,OAAO,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,SAAS,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;AAC5E,CAAC;AAED,SAAS,eAAe,CAAC,EAAW,EAAE,EAAW,EAAE,IAAiB;IAClE,mEAAmE;IACnE,MAAM,UAAU,GAAG,EAAE,CAAC,OAAO,CAAC;IAC9B,MAAM,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC;IAC7D,MAAM,CAAC,GAAG,IAAA,qBAAS,EAAC,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IAChG,MAAM,QAAQ,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,CAAC;IACvD,OAAO,IAAA,gBAAO,EAAC,QAAQ,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;AACpC,CAAC"}

package/dist/refinement-types/types.d.ts

@@ -0,0 +1,64 @@
+export type BaseType = 'Int' | 'Bool' | 'String' | {
+    kind: 'arrow';
+    from: RefType;
+    to: RefType;
+};
+export interface RefType {
+    base: BaseType;
+    /** Nombre de la variable de binding usada por el predicado (e.g. "x"). */
+    binding: string;
+    /** Predicado P(binding); cadena vacía o "true" significa "sin refinamiento". */
+    predicate: string;
+}
+export type RTerm = {
+    kind: 'lit';
+    value: number | boolean | string;
+} | {
+    kind: 'var';
+    name: string;
+} | {
+    kind: 'binop';
+    op: '+' | '-' | '*' | '<' | '<=' | '>' | '>=' | '==' | '!=' | '&&' | '||';
+    left: RTerm;
+    right: RTerm;
+} | {
+    kind: 'if';
+    cond: RTerm;
+    then: RTerm;
+    else: RTerm;
+} | {
+    kind: 'lam';
+    param: string;
+    paramType: RefType;
+    body: RTerm;
+} | {
+    kind: 'app';
+    fn: RTerm;
+    arg: RTerm;
+} | {
+    kind: 'let';
+    bind: string;
+    bindType?: RefType;
+    value: RTerm;
+    body: RTerm;
+};
+export declare const tInt: (binding?: string, predicate?: string) => RefType;
+export declare const tBool: (binding?: string, predicate?: string) => RefType;
+export declare const tString: (binding?: string, predicate?: string) => RefType;
+export declare const tArrow: (from: RefType, to: RefType, binding?: string, predicate?: string) => RefType;
+export declare const refine: (base: BaseType, binding: string, predicate: string) => RefType;
+export declare const rLit: (value: number | boolean | string) => RTerm;
+export declare const rVar: (name: string) => RTerm;
+export declare const rBinop: (op: Extract<RTerm, {
+    kind: "binop";
+}>["op"], left: RTerm, right: RTerm) => RTerm;
+export declare const rIf: (cond: RTerm, t: RTerm, e: RTerm) => RTerm;
+export declare const rLam: (param: string, paramType: RefType, body: RTerm) => RTerm;
+export declare const rApp: (fn: RTerm, arg: RTerm) => RTerm;
+export declare const rLet: (bind: string, value: RTerm, body: RTerm, bindType?: RefType) => RTerm;
+export declare function eqBase(a: BaseType, b: BaseType): boolean;
+export declare function eqRefType(a: RefType, b: RefType): boolean;
+export declare function baseToString(b: BaseType): string;
+export declare function refTypeToString(t: RefType): string;
+export declare function termToString(t: RTerm): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/refinement-types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/refinement-types/types.ts"],"names":[],"mappings":"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"}

package/dist/refinement-types/types.js

@@ -0,0 +1,130 @@
+"use strict";
+// ============================================================
+// Refinement types — AST, tipos refinados y términos
+// ============================================================
+//
+// Un tipo refinado expresa { x : B | P(x) } donde:
+//   - B es un tipo base (Int / Bool / String / arrow)
+//   - x es la variable de binding
+//   - P(x) es un predicado escrito como expresión sintáctica
+//     (cadenas de la forma "x > 0 && x < 100").
+//
+// El módulo es minimalista (al estilo Liquid Haskell didáctico):
+// el solver de VCs no es Z3 — es un evaluador/SAT-search sobre
+// enteros y booleanos suficiente para los predicados que se
+// construyen en los tests y para casos pequeños de subtipado.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rLet = exports.rApp = exports.rLam = exports.rIf = exports.rBinop = exports.rVar = exports.rLit = exports.refine = exports.tArrow = exports.tString = exports.tBool = exports.tInt = void 0;
+exports.eqBase = eqBase;
+exports.eqRefType = eqRefType;
+exports.baseToString = baseToString;
+exports.refTypeToString = refTypeToString;
+exports.termToString = termToString;
+// ---------- Constructores convenientes ----------
+const tInt = (binding = '_v', predicate = 'true') => ({
+    base: 'Int',
+    binding,
+    predicate,
+});
+exports.tInt = tInt;
+const tBool = (binding = '_v', predicate = 'true') => ({
+    base: 'Bool',
+    binding,
+    predicate,
+});
+exports.tBool = tBool;
+const tString = (binding = '_v', predicate = 'true') => ({
+    base: 'String',
+    binding,
+    predicate,
+});
+exports.tString = tString;
+const tArrow = (from, to, binding = '_v', predicate = 'true') => ({
+    base: { kind: 'arrow', from, to },
+    binding,
+    predicate,
+});
+exports.tArrow = tArrow;
+const refine = (base, binding, predicate) => ({
+    base,
+    binding,
+    predicate,
+});
+exports.refine = refine;
+// ---------- Constructores de términos ----------
+const rLit = (value) => ({ kind: 'lit', value });
+exports.rLit = rLit;
+const rVar = (name) => ({ kind: 'var', name });
+exports.rVar = rVar;
+const rBinop = (op, left, right) => ({ kind: 'binop', op, left, right });
+exports.rBinop = rBinop;
+const rIf = (cond, t, e) => ({
+    kind: 'if',
+    cond,
+    then: t,
+    else: e,
+});
+exports.rIf = rIf;
+const rLam = (param, paramType, body) => ({
+    kind: 'lam',
+    param,
+    paramType,
+    body,
+});
+exports.rLam = rLam;
+const rApp = (fn, arg) => ({ kind: 'app', fn, arg });
+exports.rApp = rApp;
+const rLet = (bind, value, body, bindType) => ({
+    kind: 'let',
+    bind,
+    bindType,
+    value,
+    body,
+});
+exports.rLet = rLet;
+// ---------- Igualdad estructural de tipos base ----------
+function eqBase(a, b) {
+    if (typeof a === 'string' || typeof b === 'string')
+        return a === b;
+    // both arrows
+    return eqRefType(a.from, b.from) && eqRefType(a.to, b.to);
+}
+function eqRefType(a, b) {
+    if (!eqBase(a.base, b.base))
+        return false;
+    // No exigimos la igualdad textual del predicado a este nivel; el chequeo de
+    // subtipado se ocupa de la equivalencia semántica (P ↔ Q).
+    return true;
+}
+// ---------- Serialización legible ----------
+function baseToString(b) {
+    if (typeof b === 'string')
+        return b;
+    return `(${refTypeToString(b.from)}) -> (${refTypeToString(b.to)})`;
+}
+function refTypeToString(t) {
+    const pred = t.predicate.trim();
+    if (pred === '' || pred === 'true') {
+        return `{ ${t.binding} : ${baseToString(t.base)} }`;
+    }
+    return `{ ${t.binding} : ${baseToString(t.base)} | ${pred} }`;
+}
+function termToString(t) {
+    switch (t.kind) {
+        case 'lit':
+            return typeof t.value === 'string' ? JSON.stringify(t.value) : String(t.value);
+        case 'var':
+            return t.name;
+        case 'binop':
+            return `(${termToString(t.left)} ${t.op} ${termToString(t.right)})`;
+        case 'if':
+            return `if ${termToString(t.cond)} then ${termToString(t.then)} else ${termToString(t.else)}`;
+        case 'lam':
+            return `(λ ${t.param} : ${refTypeToString(t.paramType)} . ${termToString(t.body)})`;
+        case 'app':
+            return `(${termToString(t.fn)} ${termToString(t.arg)})`;
+        case 'let':
+            return `let ${t.bind}${t.bindType ? ` : ${refTypeToString(t.bindType)}` : ''} = ${termToString(t.value)} in ${termToString(t.body)}`;
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/refinement-types/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/refinement-types/types.ts"],"names":[],"mappings":"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"}

package/dist/runtime/anti-unification/anti-unify.d.ts

@@ -0,0 +1,22 @@
+import type { AntiUnificationResult, FreshSupply, Term } from './types';
+/**
+ * Fuente default de variables frescas: _g0, _g1, _g2, …
+ *
+ * Se devuelve una NUEVA instancia por llamada para evitar estado
+ * compartido entre invocaciones de antiUnify.
+ */
+export declare function defaultFreshSupply(prefix?: string): FreshSupply;
+/**
+ * Anti-unification de dos términos.
+ *
+ * Devuelve el lgg (least general generalization) junto con las
+ * sustituciones de izquierda y derecha que reconstruyen los
+ * términos originales.
+ *
+ * Complejidad: O(|t1| + |t2|) tiempo si la tabla se implementa con
+ * hashing O(1). Usamos `termKey` que serializa, así que es
+ * O((|t1| + |t2|)·k) donde k es el tamaño del subtérmino más grande
+ * que aparezca en un desacuerdo.
+ */
+export declare function antiUnify(t1: Term, t2: Term, freshSupply?: FreshSupply): AntiUnificationResult;
+//# sourceMappingURL=anti-unify.d.ts.map

package/dist/runtime/anti-unification/anti-unify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anti-unify.d.ts","sourceRoot":"","sources":["../../../src/runtime/anti-unification/anti-unify.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,qBAAqB,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAGxE;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,GAAE,MAAa,GAAG,WAAW,CAGrE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,qBAAqB,CAc9F"}

package/dist/runtime/anti-unification/anti-unify.js

@@ -0,0 +1,154 @@
+"use strict";
+// ============================================================
+// ST Anti-Unification — Algoritmo de Plotkin (lgg)
+// ============================================================
+//
+// Algoritmo (Plotkin 1970):
+//
+//   au(t1, t2, table):
+//     si t1 ≡ t2 estructuralmente:
+//       return t1
+//     si ambos son func/const con mismo nombre y misma aridad:
+//       return func(name, [au(t1.args[i], t2.args[i]) for i])
+//     // desacuerdo: introducimos fresh var, reusando si ya existe
+//     // una asignada al MISMO par (t1, t2) — esto es clave para que
+//     // la generalización sea LEAST (most specific).
+//     si table tiene (t1, t2) → v entonces return v
+//     v := freshSupply()
+//     table[(t1, t2)] := v
+//     return v
+//
+// La tabla de correspondencias se mantiene globalmente durante la
+// recursión para que múltiples ocurrencias del mismo desacuerdo
+// reciban la misma fresh var. Sin esta tabla obtendríamos una
+// generalización menos específica (e.g., au(p(a,a), p(b,b)) daría
+// p(X, Y) en vez de p(X, X)).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFreshSupply = defaultFreshSupply;
+exports.antiUnify = antiUnify;
+const term_utils_1 = require("./term-utils");
+/**
+ * Fuente default de variables frescas: _g0, _g1, _g2, …
+ *
+ * Se devuelve una NUEVA instancia por llamada para evitar estado
+ * compartido entre invocaciones de antiUnify.
+ */
+function defaultFreshSupply(prefix = '_g') {
+    let counter = 0;
+    return () => `${prefix}${counter++}`;
+}
+/**
+ * Anti-unification de dos términos.
+ *
+ * Devuelve el lgg (least general generalization) junto con las
+ * sustituciones de izquierda y derecha que reconstruyen los
+ * términos originales.
+ *
+ * Complejidad: O(|t1| + |t2|) tiempo si la tabla se implementa con
+ * hashing O(1). Usamos `termKey` que serializa, así que es
+ * O((|t1| + |t2|)·k) donde k es el tamaño del subtérmino más grande
+ * que aparezca en un desacuerdo.
+ */
+function antiUnify(t1, t2, freshSupply) {
+    const supply = freshSupply ?? defaultFreshSupply();
+    // Tabla de desacuerdos: clave canónica "t1║t2" → nombre de var fresca.
+    const table = new Map();
+    // Sustituciones de salida: para cada fresh var, qué término iba en
+    // cada lado.
+    const substLeft = new Map();
+    const substRight = new Map();
+    // Orden de introducción de las fresh vars (para `variables`).
+    const variables = [];
+    const generalization = antiUnifyAux(t1, t2, table, substLeft, substRight, variables, supply);
+    return { generalization, substLeft, substRight, variables };
+}
+/**
+ * Núcleo recursivo del algoritmo. Se mantiene recursivo (no iterativo)
+ * porque la mayoría de términos en la práctica son superficiales y la
+ * recursión sigue la estructura del término más pequeño.
+ *
+ * Si en algún momento aparecen términos patológicamente profundos,
+ * habría que reescribirlo con un stack explícito siguiendo el patrón
+ * de `mapTerm` en term-rewriting/term-utils.ts.
+ */
+function antiUnifyAux(t1, t2, table, substLeft, substRight, variables, supply) {
+    // Caso base: estructuralmente iguales → la generalización es el
+    // término mismo, sin nuevas variables.
+    if ((0, term_utils_1.termEquals)(t1, t2))
+        return t1;
+    // Misma "cabeza" (mismo símbolo, misma aridad, mismo kind func/const)
+    // → recursamos argumento a argumento.
+    if (sameHead(t1, t2)) {
+        const args1 = t1.args ?? [];
+        const args2 = t2.args ?? [];
+        // sameHead garantiza aridad igual.
+        const newArgs = new Array(args1.length);
+        for (let i = 0; i < args1.length; i++) {
+            const a1 = args1[i];
+            const a2 = args2[i];
+            if (a1 === undefined || a2 === undefined) {
+                // Imposible si sameHead pasó, pero el chequeo apacigua a TS
+                // bajo noUncheckedIndexedAccess.
+                throw new Error('antiUnify: aridad inconsistente tras sameHead check');
+            }
+            newArgs[i] = antiUnifyAux(a1, a2, table, substLeft, substRight, variables, supply);
+        }
+        if (t1.kind === 'const') {
+            // const con args=[] ya cayó en termEquals; si llegamos aquí con
+            // kind=const es porque ambos tienen mismo nombre y 0 args, lo
+            // que ya implicaría termEquals=true. Defensa por si llega un
+            // const con args>0 mal construido.
+            return { kind: 'const', name: t1.name };
+        }
+        return { kind: 'func', name: t1.name, args: newArgs };
+    }
+    // Desacuerdo: pares distintos. Reutilizamos la fresh var si ya
+    // habíamos visto este par; de lo contrario generamos una nueva.
+    const key = pairKey(t1, t2);
+    const existing = table.get(key);
+    if (existing !== undefined) {
+        return { kind: 'var', name: existing };
+    }
+    const fresh = supply();
+    table.set(key, fresh);
+    substLeft.set(fresh, t1);
+    substRight.set(fresh, t2);
+    variables.push(fresh);
+    return { kind: 'var', name: fresh };
+}
+/**
+ * ¿t1 y t2 comparten la misma "cabeza" (símbolo + aridad + kind no-var)?
+ *
+ * Variables NUNCA tienen cabeza común con otra cosa: el caso `var, var`
+ * con mismos nombres ya lo absorbe `termEquals` arriba; con nombres
+ * distintos es un desacuerdo legítimo. Un `var` contra `func/const`
+ * también es desacuerdo (la variable es más general).
+ */
+function sameHead(t1, t2) {
+    if (t1.kind === 'var' || t2.kind === 'var')
+        return false;
+    // Tratamos const como func(name, []) para comparar aridad.
+    if (t1.name !== t2.name)
+        return false;
+    const a1 = t1.args ?? [];
+    const a2 = t2.args ?? [];
+    if (a1.length !== a2.length)
+        return false;
+    // Si los kinds difieren (func vs const) pero la aridad es 0 y los
+    // nombres coinciden, todavía lo aceptamos como "misma cabeza" para
+    // ser tolerantes con clientes que mezclen ambas convenciones.
+    // Pero antes de aceptar, exigimos que si difieren los kinds, la
+    // aridad sea 0 — un `const` con args no debería existir.
+    if (t1.kind !== t2.kind && a1.length > 0)
+        return false;
+    return true;
+}
+/**
+ * Clave canónica para un par (t1, t2) usada en la tabla de
+ * desacuerdos. Usamos un separador que no puede aparecer en
+ * `termKey` para evitar colisiones.
+ */
+function pairKey(t1, t2) {
+    return `${(0, term_utils_1.termKey)(t1)}║${(0, term_utils_1.termKey)(t2)}`;
+}
+//# sourceMappingURL=anti-unify.js.map

package/dist/runtime/anti-unification/anti-unify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anti-unify.js","sourceRoot":"","sources":["../../../src/runtime/anti-unification/anti-unify.ts"],"names":[],"mappings":"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"}

package/dist/runtime/anti-unification/index.d.ts

@@ -0,0 +1,6 @@
+export type { Term, AntiUnificationResult, FreshSupply } from './types';
+export { antiUnify, defaultFreshSupply } from './anti-unify';
+export { termEquals, termKey, varsOf, applySubst, termSize, v, f, c } from './term-utils';
+export { antiUnifyMany, antiUnifyManyDetailed, generalizationOrder } from './many';
+export type { AntiUnificationManyResult } from './many';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/anti-unification/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/anti-unification/index.ts"],"names":[],"mappings":"AAIA,YAAY,EAAE,IAAI,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAExE,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAE7D,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,cAAc,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAEnF,YAAY,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/runtime/anti-unification/index.js

@@ -0,0 +1,23 @@
+"use strict";
+// ============================================================
+// ST Anti-Unification — Barrel de exportaciones
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generalizationOrder = exports.antiUnifyManyDetailed = exports.antiUnifyMany = exports.c = exports.f = exports.v = exports.termSize = exports.applySubst = exports.varsOf = exports.termKey = exports.termEquals = exports.defaultFreshSupply = exports.antiUnify = void 0;
+var anti_unify_1 = require("./anti-unify");
+Object.defineProperty(exports, "antiUnify", { enumerable: true, get: function () { return anti_unify_1.antiUnify; } });
+Object.defineProperty(exports, "defaultFreshSupply", { enumerable: true, get: function () { return anti_unify_1.defaultFreshSupply; } });
+var term_utils_1 = require("./term-utils");
+Object.defineProperty(exports, "termEquals", { enumerable: true, get: function () { return term_utils_1.termEquals; } });
+Object.defineProperty(exports, "termKey", { enumerable: true, get: function () { return term_utils_1.termKey; } });
+Object.defineProperty(exports, "varsOf", { enumerable: true, get: function () { return term_utils_1.varsOf; } });
+Object.defineProperty(exports, "applySubst", { enumerable: true, get: function () { return term_utils_1.applySubst; } });
+Object.defineProperty(exports, "termSize", { enumerable: true, get: function () { return term_utils_1.termSize; } });
+Object.defineProperty(exports, "v", { enumerable: true, get: function () { return term_utils_1.v; } });
+Object.defineProperty(exports, "f", { enumerable: true, get: function () { return term_utils_1.f; } });
+Object.defineProperty(exports, "c", { enumerable: true, get: function () { return term_utils_1.c; } });
+var many_1 = require("./many");
+Object.defineProperty(exports, "antiUnifyMany", { enumerable: true, get: function () { return many_1.antiUnifyMany; } });
+Object.defineProperty(exports, "antiUnifyManyDetailed", { enumerable: true, get: function () { return many_1.antiUnifyManyDetailed; } });
+Object.defineProperty(exports, "generalizationOrder", { enumerable: true, get: function () { return many_1.generalizationOrder; } });
+//# sourceMappingURL=index.js.map

package/dist/runtime/anti-unification/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/anti-unification/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,gDAAgD;AAChD,+DAA+D;;;AAI/D,2CAA6D;AAApD,uGAAA,SAAS,OAAA;AAAE,gHAAA,kBAAkB,OAAA;AAEtC,2CAA0F;AAAjF,wGAAA,UAAU,OAAA;AAAE,qGAAA,OAAO,OAAA;AAAE,oGAAA,MAAM,OAAA;AAAE,wGAAA,UAAU,OAAA;AAAE,sGAAA,QAAQ,OAAA;AAAE,+FAAA,CAAC,OAAA;AAAE,+FAAA,CAAC,OAAA;AAAE,+FAAA,CAAC,OAAA;AAEnE,+BAAmF;AAA1E,qGAAA,aAAa,OAAA;AAAE,6GAAA,qBAAqB,OAAA;AAAE,2GAAA,mBAAmB,OAAA"}

package/dist/runtime/anti-unification/many.d.ts

@@ -0,0 +1,49 @@
+import type { AntiUnificationResult, FreshSupply, Term } from './types';
+import { applySubst } from './term-utils';
+/**
+ * Variante "detailed" del n-way lgg.
+ *
+ * Devuelve la generalización y un array `substs` de longitud n tal
+ * que substs[i] aplicada al generalization reproduce el término i.
+ */
+export interface AntiUnificationManyResult {
+    generalization: Term;
+    substs: Map<string, Term>[];
+    variables: string[];
+}
+/**
+ * Anti-unification n-aria. Reduce con la versión binaria.
+ *
+ * Para n=0 lanza error (no hay generalización sensata).
+ * Para n=1 devuelve el término sin variables nuevas.
+ */
+export declare function antiUnifyMany(terms: Term[], freshSupply?: FreshSupply): AntiUnificationResult;
+/**
+ * Versión "detailed" — devuelve las n sustituciones independientes.
+ *
+ * Esta es la forma más útil para clientes que quieren ver cómo se
+ * instancia cada uno de los n términos desde la generalización.
+ */
+export declare function antiUnifyManyDetailed(terms: Term[], freshSupply?: FreshSupply): AntiUnificationManyResult;
+/**
+ * Orden de generalidad entre dos términos.
+ *
+ * Definición: g1 ≤ g2 ⇔ existe sustitución σ con σ(g1) = g2.
+ * Es decir, g1 es MÁS GENERAL que g2 (g2 es una instancia de g1).
+ *
+ * Resultados:
+ *   - -1  si g1 es ESTRICTAMENTE más general que g2 (g1 < g2 en
+ *         generalidad inversa — equivalente: σ(g1)=g2 pero no
+ *         σ'(g2)=g1).
+ *   -  0  si son equivalentes módulo renombre (cada uno instancia
+ *         del otro vía sustitución de variables).
+ *   - +1  si g2 es estrictamente más general que g1.
+ *   - null si son INCOMPARABLES (no hay σ en ningún sentido).
+ *
+ * Nota: la convención del usuario en la spec es
+ *   generalizationOrder(X, f(X)) → -1 (X más general).
+ * Esto es coherente: X es más general que f(X), y devolvemos -1.
+ */
+export declare function generalizationOrder(g1: Term, g2: Term): -1 | 0 | 1 | null;
+export { applySubst };
+//# sourceMappingURL=many.d.ts.map

package/dist/runtime/anti-unification/many.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"many.d.ts","sourceRoot":"","sources":["../../../src/runtime/anti-unification/many.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,qBAAqB,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAExE,OAAO,EAAE,UAAU,EAAsB,MAAM,cAAc,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,cAAc,EAAE,IAAI,CAAC;IACrB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC;IAC5B,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,qBAAqB,CAyC7F;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,IAAI,EAAE,EACb,WAAW,CAAC,EAAE,WAAW,GACxB,yBAAyB,CAoB3B;AAyCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAazE;AAID,OAAO,EAAE,UAAU,EAAE,CAAC"}