@stevenvo780/st-lang 4.3.0 → 4.5.0

package/dist/coinduction/index.d.ts

@@ -0,0 +1,136 @@
+export interface Stream<T> {
+    head: T;
+    tail: () => Stream<T>;
+}
+/**
+ * Cons explícito: crea un stream con cabeza `h` y cola perezosa
+ * `t` (una función que produce el resto cuando se evalúa).
+ */
+export declare function cons<T>(h: T, t: () => Stream<T>): Stream<T>;
+/**
+ * `repeat(x)` = x, x, x, ...  (stream constante)
+ *
+ * Definición corecursiva clásica: repeat(x) = cons(x, () => repeat(x)).
+ * El thunk evita la recursión infinita en tiempo de construcción.
+ */
+export declare function repeat<T>(x: T): Stream<T>;
+/**
+ * `iterate(f, x)` = x, f(x), f(f(x)), ...
+ *
+ * Definición corecursiva: iterate(f, x) = cons(x, () => iterate(f, f(x))).
+ */
+export declare function iterate<T>(f: (x: T) => T, x: T): Stream<T>;
+/**
+ * `unfold(seed, step)`: anamorfismo genérico. `step(s)` devuelve
+ * el siguiente par `[valor, próximaSemilla]` o `null` para terminar.
+ * Para streams infinitos, `step` nunca debe devolver `null`. Si
+ * devuelve `null` durante una iteración, devolvemos un stream que
+ * cicla la última cabeza producida (decisión: streams totales).
+ */
+export declare function unfold<S, T>(seed: S, step: (s: S) => readonly [T, S] | null): Stream<T>;
+/**
+ * `take(s, n)`: extrae los primeros n elementos de un stream.
+ * Observación finita; es la única forma de "ver" un stream.
+ */
+export declare function take<T>(s: Stream<T>, n: number): T[];
+/**
+ * `drop(s, n)`: descarta los primeros n elementos.
+ */
+export declare function drop<T>(s: Stream<T>, n: number): Stream<T>;
+/**
+ * `nth(s, i)`: i-ésimo elemento (0-indexed).
+ */
+export declare function nth<T>(s: Stream<T>, i: number): T;
+/**
+ * `map(f, s)`: aplica `f` a cada elemento.
+ *
+ * Definición corecursiva: map(f, s) = cons(f(head s), () => map(f, tail s)).
+ */
+export declare function map<T, U>(f: (x: T) => U, s: Stream<T>): Stream<U>;
+/**
+ * `zipWith(f, a, b)`: combina dos streams elemento a elemento.
+ *
+ * zipWith(f, a, b) = cons(f(head a, head b), () => zipWith(f, tail a, tail b))
+ */
+export declare function zipWith<A, B, C>(f: (a: A, b: B) => C, a: Stream<A>, b: Stream<B>): Stream<C>;
+/**
+ * `zip(a, b)`: par-zip estándar.
+ */
+export declare function zip<A, B>(a: Stream<A>, b: Stream<B>): Stream<[A, B]>;
+/**
+ * `filter(pred, s)`: PRECONDICIÓN — el predicado debe ser satisfecho
+ * infinitas veces, de lo contrario el stream resultante se "atasca".
+ * No protegemos contra eso porque coinductivamente no es decidible.
+ */
+export declare function filter<T>(pred: (x: T) => boolean, s: Stream<T>): Stream<T>;
+/**
+ * naturals = 0, 1, 2, 3, ...
+ */
+export declare const naturals: Stream<number>;
+export declare const fibonacci: Stream<number>;
+export interface BisimulationProof<T> {
+    /** Par inicial cuyo membership en la bisimulación queremos probar. */
+    initial: [Stream<T>, Stream<T>];
+    /**
+     * Relación candidata R. Por bisimulación, basta que R sea una
+     * "bisimulación up-to": cerrada bajo los destructores en el sentido
+     * de que R(s,t) ⇒ R(tail s, tail t).
+     */
+    relation: (a: Stream<T>, b: Stream<T>) => boolean;
+}
+/**
+ * `isBisimilar(a, b, depth)`: chequeo de bisimilaridad acotado.
+ * Compara cabezas hasta profundidad `depth`. Retorna `false` apenas
+ * encuentra una divergencia (refutación constructiva); retorna `true`
+ * si los primeros `depth` elementos coinciden (evidencia positiva
+ * acotada — para una prueba real de bisimilaridad, usar `prove`).
+ *
+ * Usa `Object.is` para comparar primitivos. Para tipos compuestos
+ * el caller debería envolver con un equality explícito (no hacemos
+ * deep-equals porque tendría costo no obvio y semántica ambigua).
+ */
+export declare function isBisimilar<T>(a: Stream<T>, b: Stream<T>, depth?: number): boolean;
+/**
+ * Igualdad observacional para elementos de un stream. Soportamos:
+ *   • primitivos (===, con Object.is para NaN/+0/-0)
+ *   • arrays y tuplas (recursión elemento a elemento)
+ *   • objetos planos por keys propias
+ * No hace circular-detection: si pasás un grafo cíclico, va a colgar.
+ */
+declare function equal(x: unknown, y: unknown): boolean;
+/**
+ * `prove(claim, depth)`: aplica la técnica de bisimulación up-to.
+ *
+ * Algoritmo: empieza con el par inicial, y para cada paso i ∈ [0, depth):
+ *   1. Verifica que la relación R sostenga el par actual (a_i, b_i).
+ *   2. Verifica que las cabezas sean iguales: head(a_i) = head(b_i).
+ *   3. Avanza: a_{i+1} = tail(a_i), b_{i+1} = tail(b_i).
+ *
+ * Si la relación R es genuinamente una bisimulación (clausurada bajo
+ * tail), todos los pasos pasarán para cualquier `depth`. El método
+ * es completo "en el límite": probar para `depth = ∞` ≡ probar bisim.
+ * En la práctica devolvemos true si depth pasos pasaron sin error.
+ *
+ * Si la relación falla en algún paso, retornamos false (evidencia de
+ * que R no es una bisimulación, o de que (a, b) no es bisimilar).
+ */
+export declare function prove<T>(claim: BisimulationProof<T>, depth?: number): boolean;
+/**
+ * `interleave(a, b)`: intercala a, b, a, b, ... toma 1 de a luego 1 de b.
+ *
+ * interleave(a, b) = cons(head a, () => interleave(b, tail a))
+ *
+ * Nota: el "switch" entre a y b se hace por el truco clásico:
+ * llamar recursivamente con los argumentos invertidos.
+ */
+export declare function interleave<T>(a: Stream<T>, b: Stream<T>): Stream<T>;
+/**
+ * `scan(f, init, s)`: prefijos acumulados; análogo a Array.prototype.reduce
+ * pero coinductivo. scan(+, 0, naturals) = 0, 0, 1, 3, 6, 10, ...
+ */
+export declare function scan<T, U>(f: (acc: U, x: T) => U, init: U, s: Stream<T>): Stream<U>;
+export declare const __internals: {
+    equal: typeof equal;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/coinduction/index.d.ts.map

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

package/dist/coinduction/index.js

@@ -0,0 +1,318 @@
+"use strict";
+// ============================================================
+// ST Coinduction — Streams + corecursion + bisimulación up-to
+// ============================================================
+// Streams coinductivos definidos por destructores (head, tail).
+// Construcción corecursiva via thunks perezosos (la cola es una
+// función `() => Stream<T>` para evitar evaluación infinita).
+//
+// Bisimulación: la noción natural de igualdad para streams. Dos
+// streams `s, t` son bisimilares si existe una relación R tal que
+//   • R(s, t) ⇒ head(s) = head(t)
+//   • R(s, t) ⇒ R(tail(s), tail(t))
+// La igualdad sintáctica falla (dos streams pueden generar la
+// misma secuencia con thunks distintos); la bisimulación es la
+// clausura coinductiva apropiada.
+//
+// Como las secuencias son infinitas no podemos verificar
+// bisimilaridad en general (semi-decidible). Por eso ofrecemos:
+//   • isBisimilar(a, b, depth): chequeo "hasta profundidad", suficiente
+//     para refutación (encontrar el primer prefijo divergente) y para
+//     evidencia computacional positiva acotada.
+//   • prove(claim, depth): técnica "bisimulación up-to". El usuario
+//     provee una relación R; chequeamos por `depth` pasos que
+//       R(a,b) ⇒ head(a)=head(b) ∧ R(tail a, tail b).
+//     Si la relación es realmente una bisimulación, ningún paso falla;
+//     si depth pasos pasaron sin fallar, tenemos alta confianza
+//     (en el caso límite, todos los pasos válidos = bisimulación).
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__internals = exports.fibonacci = exports.naturals = void 0;
+exports.cons = cons;
+exports.repeat = repeat;
+exports.iterate = iterate;
+exports.unfold = unfold;
+exports.take = take;
+exports.drop = drop;
+exports.nth = nth;
+exports.map = map;
+exports.zipWith = zipWith;
+exports.zip = zip;
+exports.filter = filter;
+exports.isBisimilar = isBisimilar;
+exports.prove = prove;
+exports.interleave = interleave;
+exports.scan = scan;
+// ── Constructores ───────────────────────────────────────────
+/**
+ * Cons explícito: crea un stream con cabeza `h` y cola perezosa
+ * `t` (una función que produce el resto cuando se evalúa).
+ */
+function cons(h, t) {
+    return { head: h, tail: t };
+}
+/**
+ * `repeat(x)` = x, x, x, ...  (stream constante)
+ *
+ * Definición corecursiva clásica: repeat(x) = cons(x, () => repeat(x)).
+ * El thunk evita la recursión infinita en tiempo de construcción.
+ */
+function repeat(x) {
+    // Truco para evitar reconstruir el objeto en cada `tail`: usamos
+    // un nodo que se referencia a sí mismo. Esto preserva la semántica
+    // (tail(repeat x) = repeat x) y además garantiza punto-fijo.
+    const node = { head: x, tail: () => node };
+    return node;
+}
+/**
+ * `iterate(f, x)` = x, f(x), f(f(x)), ...
+ *
+ * Definición corecursiva: iterate(f, x) = cons(x, () => iterate(f, f(x))).
+ */
+function iterate(f, x) {
+    return { head: x, tail: () => iterate(f, f(x)) };
+}
+/**
+ * `unfold(seed, step)`: anamorfismo genérico. `step(s)` devuelve
+ * el siguiente par `[valor, próximaSemilla]` o `null` para terminar.
+ * Para streams infinitos, `step` nunca debe devolver `null`. Si
+ * devuelve `null` durante una iteración, devolvemos un stream que
+ * cicla la última cabeza producida (decisión: streams totales).
+ */
+function unfold(seed, step) {
+    const next = step(seed);
+    if (next === null) {
+        // Streams en este módulo son totales; si el cliente decide terminar,
+        // estabilizamos en un punto fijo trivial usando undefined.
+        // En la práctica, los callers no deberían llamar unfold con un step
+        // que puede devolver null si esperan un stream infinito.
+        throw new Error('unfold: step returned null on infinite stream');
+    }
+    const [value, nextSeed] = next;
+    return { head: value, tail: () => unfold(nextSeed, step) };
+}
+// ── Destructores y observaciones ────────────────────────────
+/**
+ * `take(s, n)`: extrae los primeros n elementos de un stream.
+ * Observación finita; es la única forma de "ver" un stream.
+ */
+function take(s, n) {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error(`take: n debe ser entero no-negativo, recibido ${n}`);
+    }
+    const out = [];
+    let cur = s;
+    for (let i = 0; i < n; i++) {
+        out.push(cur.head);
+        cur = cur.tail();
+    }
+    return out;
+}
+/**
+ * `drop(s, n)`: descarta los primeros n elementos.
+ */
+function drop(s, n) {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error(`drop: n debe ser entero no-negativo, recibido ${n}`);
+    }
+    let cur = s;
+    for (let i = 0; i < n; i++)
+        cur = cur.tail();
+    return cur;
+}
+/**
+ * `nth(s, i)`: i-ésimo elemento (0-indexed).
+ */
+function nth(s, i) {
+    return drop(s, i).head;
+}
+// ── Functor / aplicativos ───────────────────────────────────
+/**
+ * `map(f, s)`: aplica `f` a cada elemento.
+ *
+ * Definición corecursiva: map(f, s) = cons(f(head s), () => map(f, tail s)).
+ */
+function map(f, s) {
+    return { head: f(s.head), tail: () => map(f, s.tail()) };
+}
+/**
+ * `zipWith(f, a, b)`: combina dos streams elemento a elemento.
+ *
+ * zipWith(f, a, b) = cons(f(head a, head b), () => zipWith(f, tail a, tail b))
+ */
+function zipWith(f, a, b) {
+    return {
+        head: f(a.head, b.head),
+        tail: () => zipWith(f, a.tail(), b.tail()),
+    };
+}
+/**
+ * `zip(a, b)`: par-zip estándar.
+ */
+function zip(a, b) {
+    return zipWith((x, y) => [x, y], a, b);
+}
+/**
+ * `filter(pred, s)`: PRECONDICIÓN — el predicado debe ser satisfecho
+ * infinitas veces, de lo contrario el stream resultante se "atasca".
+ * No protegemos contra eso porque coinductivamente no es decidible.
+ */
+function filter(pred, s) {
+    let cur = s;
+    while (!pred(cur.head)) {
+        cur = cur.tail();
+    }
+    const advanced = cur;
+    return {
+        head: advanced.head,
+        tail: () => filter(pred, advanced.tail()),
+    };
+}
+// ── Streams notables ────────────────────────────────────────
+/**
+ * naturals = 0, 1, 2, 3, ...
+ */
+exports.naturals = iterate((n) => n + 1, 0);
+/**
+ * fibonacci = 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
+ *
+ * Definición clásica corecursiva (Hinze):
+ *   fib = 0 :: 1 :: zipWith(+, fib, tail fib)
+ *
+ * En TypeScript necesitamos un thunk que se autorreferencie. Lo
+ * implementamos con una closure que devuelve siempre el mismo nodo.
+ */
+function makeFibonacci() {
+    // fib(n) clásico vía iterate sobre el par (a, b) = (fib n, fib (n+1)).
+    // Equivalente computacionalmente a la definición zipWith pero sin
+    // requerir auto-referencia en TS (que generaría thunks anidados
+    // exponencialmente sin memoización).
+    return map(([a, _b]) => a, iterate(([a, b]) => [b, a + b], [0, 1]));
+}
+exports.fibonacci = makeFibonacci();
+const DEFAULT_DEPTH = 64;
+/**
+ * `isBisimilar(a, b, depth)`: chequeo de bisimilaridad acotado.
+ * Compara cabezas hasta profundidad `depth`. Retorna `false` apenas
+ * encuentra una divergencia (refutación constructiva); retorna `true`
+ * si los primeros `depth` elementos coinciden (evidencia positiva
+ * acotada — para una prueba real de bisimilaridad, usar `prove`).
+ *
+ * Usa `Object.is` para comparar primitivos. Para tipos compuestos
+ * el caller debería envolver con un equality explícito (no hacemos
+ * deep-equals porque tendría costo no obvio y semántica ambigua).
+ */
+function isBisimilar(a, b, depth = DEFAULT_DEPTH) {
+    if (!Number.isInteger(depth) || depth < 0) {
+        throw new Error(`isBisimilar: depth debe ser entero no-negativo, recibido ${depth}`);
+    }
+    let curA = a;
+    let curB = b;
+    for (let i = 0; i < depth; i++) {
+        if (!equal(curA.head, curB.head))
+            return false;
+        curA = curA.tail();
+        curB = curB.tail();
+    }
+    return true;
+}
+/**
+ * Igualdad observacional para elementos de un stream. Soportamos:
+ *   • primitivos (===, con Object.is para NaN/+0/-0)
+ *   • arrays y tuplas (recursión elemento a elemento)
+ *   • objetos planos por keys propias
+ * No hace circular-detection: si pasás un grafo cíclico, va a colgar.
+ */
+function equal(x, y) {
+    if (Object.is(x, y))
+        return true;
+    if (typeof x !== typeof y)
+        return false;
+    if (x === null || y === null)
+        return false;
+    if (typeof x !== 'object')
+        return false;
+    if (Array.isArray(x) !== Array.isArray(y))
+        return false;
+    if (Array.isArray(x) && Array.isArray(y)) {
+        if (x.length !== y.length)
+            return false;
+        for (let i = 0; i < x.length; i++) {
+            if (!equal(x[i], y[i]))
+                return false;
+        }
+        return true;
+    }
+    const ox = x;
+    const oy = y;
+    const kx = Object.keys(ox);
+    const ky = Object.keys(oy);
+    if (kx.length !== ky.length)
+        return false;
+    for (const k of kx) {
+        if (!Object.prototype.hasOwnProperty.call(oy, k))
+            return false;
+        if (!equal(ox[k], oy[k]))
+            return false;
+    }
+    return true;
+}
+/**
+ * `prove(claim, depth)`: aplica la técnica de bisimulación up-to.
+ *
+ * Algoritmo: empieza con el par inicial, y para cada paso i ∈ [0, depth):
+ *   1. Verifica que la relación R sostenga el par actual (a_i, b_i).
+ *   2. Verifica que las cabezas sean iguales: head(a_i) = head(b_i).
+ *   3. Avanza: a_{i+1} = tail(a_i), b_{i+1} = tail(b_i).
+ *
+ * Si la relación R es genuinamente una bisimulación (clausurada bajo
+ * tail), todos los pasos pasarán para cualquier `depth`. El método
+ * es completo "en el límite": probar para `depth = ∞` ≡ probar bisim.
+ * En la práctica devolvemos true si depth pasos pasaron sin error.
+ *
+ * Si la relación falla en algún paso, retornamos false (evidencia de
+ * que R no es una bisimulación, o de que (a, b) no es bisimilar).
+ */
+function prove(claim, depth = DEFAULT_DEPTH) {
+    if (!Number.isInteger(depth) || depth < 0) {
+        throw new Error(`prove: depth debe ser entero no-negativo, recibido ${depth}`);
+    }
+    let [curA, curB] = claim.initial;
+    for (let i = 0; i < depth; i++) {
+        if (!claim.relation(curA, curB))
+            return false;
+        if (!equal(curA.head, curB.head))
+            return false;
+        curA = curA.tail();
+        curB = curB.tail();
+    }
+    return true;
+}
+// ── Utilidades para combinar streams (Hinze classics) ──────
+/**
+ * `interleave(a, b)`: intercala a, b, a, b, ... toma 1 de a luego 1 de b.
+ *
+ * interleave(a, b) = cons(head a, () => interleave(b, tail a))
+ *
+ * Nota: el "switch" entre a y b se hace por el truco clásico:
+ * llamar recursivamente con los argumentos invertidos.
+ */
+function interleave(a, b) {
+    return {
+        head: a.head,
+        tail: () => interleave(b, a.tail()),
+    };
+}
+/**
+ * `scan(f, init, s)`: prefijos acumulados; análogo a Array.prototype.reduce
+ * pero coinductivo. scan(+, 0, naturals) = 0, 0, 1, 3, 6, 10, ...
+ */
+function scan(f, init, s) {
+    return {
+        head: init,
+        tail: () => scan(f, f(init, s.head), s.tail()),
+    };
+}
+// ── Exports auxiliares para tests ───────────────────────────
+exports.__internals = { equal };
+//# sourceMappingURL=index.js.map

package/dist/coinduction/index.js.map

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

package/dist/combinators-ski/abstract.d.ts

@@ -0,0 +1,5 @@
+import type { Term as LambdaTerm } from '../lambda-calc/types';
+import type { CTerm } from './types';
+export declare function abstractFromLambda(t: LambdaTerm): CTerm;
+export declare function toLambda(c: CTerm): LambdaTerm;
+//# sourceMappingURL=abstract.d.ts.map

package/dist/combinators-ski/abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract.d.ts","sourceRoot":"","sources":["../../src/combinators-ski/abstract.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIrC,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,UAAU,GAAG,KAAK,CAYvD;AA+BD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,GAAG,UAAU,CAmB7C"}

package/dist/combinators-ski/abstract.js

@@ -0,0 +1,88 @@
+"use strict";
+// ============================================================
+// Bracket abstraction: λ-cálculo → SKI
+// ============================================================
+//
+// Algoritmo clásico de Curry para eliminar λ-abstracciones, traducido
+// como `lambda x . T  ≡  [x] T` con las reglas:
+//
+//   [x] x         = I
+//   [x] M         = K M             si x ∉ FV(M)
+//   [x] (M N)     = S ([x] M) ([x] N)
+//
+// Es el llamado "algoritmo (abc)" — simple, no optimizado: produce
+// términos grandes pero correctos. Hay variantes que aprovechan
+// patrones como `[x] (M x) = M` (η) o introducen B, C, W, T, K' para
+// reducir tamaño; aquí elegimos la canónica por claridad pedagógica.
+//
+// `toLambda` hace el camino inverso: codifica S, K, I como las
+// λ-abstracciones que los definen. No pretende invertir
+// `abstractFromLambda` exactamente — el round-trip es semántico
+// (alpha/beta-eta equivalente), no sintáctico.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abstractFromLambda = abstractFromLambda;
+exports.toLambda = toLambda;
+const types_1 = require("../lambda-calc/types");
+const types_2 = require("./types");
+// Convierte un λ-término a SKI puro (sólo S, K, I y variables libres).
+function abstractFromLambda(t) {
+    switch (t.kind) {
+        case 'var':
+            return (0, types_2.cvar)(t.name);
+        case 'app':
+            return { kind: 'app', fn: abstractFromLambda(t.fn), arg: abstractFromLambda(t.arg) };
+        case 'abs': {
+            // [param] body
+            const inner = abstractFromLambda(t.body);
+            return bracket(t.param, inner);
+        }
+    }
+}
+// [x] T  con T ya en SKI.
+function bracket(x, t) {
+    // [x] x = I
+    if (t.kind === 'var' && t.name === x)
+        return (0, types_2.I)();
+    // [x] M  = K M     si x ∉ FV(M)
+    if (!(0, types_2.freeVars)(t).has(x))
+        return (0, types_2.app)((0, types_2.K)(), t);
+    // En este punto t es necesariamente una aplicación: si fuese una
+    // constante S/K/I no tendría FV, y si fuese `var` su nombre ≠ x ya
+    // habría caído en la rama K. Mantengo el switch para que TS
+    // narrowee y queden cubiertas las ramas restantes.
+    switch (t.kind) {
+        case 'app':
+            // [x] (M N) = S ([x] M) ([x] N)
+            return (0, types_2.app)((0, types_2.S)(), bracket(x, t.fn), bracket(x, t.arg));
+        case 'var':
+        case 'S':
+        case 'K':
+        case 'I':
+            // Inalcanzable por las guardas previas; reproducimos K-rule
+            // por defensa para no caer en undefined.
+            return (0, types_2.app)((0, types_2.K)(), t);
+    }
+}
+// SKI → λ-cálculo. Codifica S, K, I como sus definiciones lambda
+// canónicas y deja las variables libres como variables. Útil para
+// round-trip: el resultado, normalizado en λ, debe ser
+// alpha-equivalente al término original aplicado a los mismos
+// argumentos (la equivalencia es semántica, no sintáctica).
+function toLambda(c) {
+    switch (c.kind) {
+        case 'I':
+            // I = λx.x
+            return (0, types_1.lam)('x', (0, types_1.v)('x'));
+        case 'K':
+            // K = λx.λy.x
+            return (0, types_1.lam)('x', (0, types_1.lam)('y', (0, types_1.v)('x')));
+        case 'S':
+            // S = λx.λy.λz. x z (y z)
+            return (0, types_1.lam)('x', (0, types_1.lam)('y', (0, types_1.lam)('z', (0, types_1.apN)((0, types_1.v)('x'), (0, types_1.v)('z'), (0, types_1.ap)((0, types_1.v)('y'), (0, types_1.v)('z'))))));
+        case 'var':
+            return (0, types_1.v)(c.name);
+        case 'app':
+            return (0, types_1.ap)(toLambda(c.fn), toLambda(c.arg));
+    }
+}
+//# sourceMappingURL=abstract.js.map

package/dist/combinators-ski/abstract.js.map

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

package/dist/combinators-ski/index.d.ts

@@ -0,0 +1,6 @@
+export type { CTerm } from './types';
+export { S, K, I, cvar, app, ctermEq, freeVars, termToString } from './types';
+export { reduceStep, normalize, isNormalForm } from './reduce';
+export type { NormalizeResult } from './reduce';
+export { abstractFromLambda, toLambda } from './abstract';
+//# sourceMappingURL=index.d.ts.map

package/dist/combinators-ski/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/combinators-ski/index.ts"],"names":[],"mappings":"AAWA,YAAY,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE9E,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC/D,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/combinators-ski/index.js

@@ -0,0 +1,30 @@
+"use strict";
+// ============================================================
+// SKI combinatory logic — Punto de entrada público
+// ============================================================
+//
+// API:
+//   - Tipos: CTerm
+//   - Constructores: S(), K(), I(), cvar, app
+//   - Estructura: ctermEq, freeVars, termToString
+//   - Reducción: reduceStep, normalize, isNormalForm, NormalizeResult
+//   - Bracket abstraction: abstractFromLambda, toLambda
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLambda = exports.abstractFromLambda = exports.isNormalForm = exports.normalize = exports.reduceStep = exports.termToString = exports.freeVars = exports.ctermEq = exports.app = exports.cvar = exports.I = exports.K = exports.S = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "S", { enumerable: true, get: function () { return types_1.S; } });
+Object.defineProperty(exports, "K", { enumerable: true, get: function () { return types_1.K; } });
+Object.defineProperty(exports, "I", { enumerable: true, get: function () { return types_1.I; } });
+Object.defineProperty(exports, "cvar", { enumerable: true, get: function () { return types_1.cvar; } });
+Object.defineProperty(exports, "app", { enumerable: true, get: function () { return types_1.app; } });
+Object.defineProperty(exports, "ctermEq", { enumerable: true, get: function () { return types_1.ctermEq; } });
+Object.defineProperty(exports, "freeVars", { enumerable: true, get: function () { return types_1.freeVars; } });
+Object.defineProperty(exports, "termToString", { enumerable: true, get: function () { return types_1.termToString; } });
+var reduce_1 = require("./reduce");
+Object.defineProperty(exports, "reduceStep", { enumerable: true, get: function () { return reduce_1.reduceStep; } });
+Object.defineProperty(exports, "normalize", { enumerable: true, get: function () { return reduce_1.normalize; } });
+Object.defineProperty(exports, "isNormalForm", { enumerable: true, get: function () { return reduce_1.isNormalForm; } });
+var abstract_1 = require("./abstract");
+Object.defineProperty(exports, "abstractFromLambda", { enumerable: true, get: function () { return abstract_1.abstractFromLambda; } });
+Object.defineProperty(exports, "toLambda", { enumerable: true, get: function () { return abstract_1.toLambda; } });
+//# sourceMappingURL=index.js.map

package/dist/combinators-ski/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/combinators-ski/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,mDAAmD;AACnD,+DAA+D;AAC/D,EAAE;AACF,OAAO;AACP,mBAAmB;AACnB,8CAA8C;AAC9C,kDAAkD;AAClD,sEAAsE;AACtE,wDAAwD;;;AAGxD,iCAA8E;AAArE,0FAAA,CAAC,OAAA;AAAE,0FAAA,CAAC,OAAA;AAAE,0FAAA,CAAC,OAAA;AAAE,6FAAA,IAAI,OAAA;AAAE,4FAAA,GAAG,OAAA;AAAE,gGAAA,OAAO,OAAA;AAAE,iGAAA,QAAQ,OAAA;AAAE,qGAAA,YAAY,OAAA;AAE5D,mCAA+D;AAAtD,oGAAA,UAAU,OAAA;AAAE,mGAAA,SAAS,OAAA;AAAE,sGAAA,YAAY,OAAA;AAG5C,uCAA0D;AAAjD,8GAAA,kBAAkB,OAAA;AAAE,oGAAA,QAAQ,OAAA"}

package/dist/combinators-ski/reduce.d.ts

@@ -0,0 +1,10 @@
+import type { CTerm } from './types';
+export declare function reduceStep(t: CTerm): CTerm | null;
+export interface NormalizeResult {
+    result: CTerm;
+    steps: number;
+    terminated: boolean;
+}
+export declare function normalize(t: CTerm, maxSteps?: number): NormalizeResult;
+export declare function isNormalForm(t: CTerm): boolean;
+//# sourceMappingURL=reduce.d.ts.map

package/dist/combinators-ski/reduce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce.d.ts","sourceRoot":"","sources":["../../src/combinators-ski/reduce.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGrC,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI,CAgBjD;AA2DD,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;CACrB;AAKD,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,SAAO,GAAG,eAAe,CASpE;AAGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO,CAE9C"}