mcard-js 2.1.1 → 2.1.2

package/dist/ptr/lambda/BetaReduction.js

@@ -0,0 +1,322 @@
+/**
+ * Beta Reduction (β-reduction)
+ *
+ * The computational heart of Lambda Calculus - function application.
+ *
+ * Rule: (λx.M) N →β M[x:=N]
+ *
+ * A term of the form (λx.M) N is called a "beta-redex" (reducible expression).
+ * Beta reduction substitutes the argument N for all free occurrences of x in M.
+ *
+ * IMPORTANT: Must handle capture avoidance - if N contains free variables
+ * that would become bound in M, we must α-rename first.
+ *
+ * @module mcard-js/ptr/lambda/BetaReduction
+ */
+import { loadTerm, storeTerm, mkAbs, mkApp, isAbs, isApp } from './LambdaTerm';
+import { freeVariables, generateFresh } from './FreeVariables';
+import { alphaRename } from './AlphaConversion';
+import { IO } from '../../monads/IO';
+import { Either } from '../../monads/Either';
+import { Maybe } from '../../monads/Maybe';
+// ─────────────────────────────────────────────────────────────────────────────
+// Beta Redex Detection
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Check if a term is a beta-redex: (λx.M) N
+ */
+export function isRedex(collection, termHash) {
+    return IO.of(async () => {
+        const term = await loadTerm(collection, termHash);
+        if (!term || !isApp(term))
+            return false;
+        const func = await loadTerm(collection, term.func);
+        return func !== null && isAbs(func);
+    });
+}
+/**
+ * Find the leftmost-outermost redex (normal order reduction)
+ * Returns Maybe<hash of redex>
+ */
+export function findLeftmostRedex(collection, termHash) {
+    return IO.of(async () => {
+        return findRedexNormalOrder(collection, termHash);
+    });
+}
+async function findRedexNormalOrder(collection, termHash) {
+    const term = await loadTerm(collection, termHash);
+    if (!term)
+        return Maybe.nothing();
+    switch (term.tag) {
+        case 'Var':
+            // Variables are not redexes
+            return Maybe.nothing();
+        case 'Abs':
+            // Look inside the body
+            return findRedexNormalOrder(collection, term.body);
+        case 'App': {
+            // Check if this application is a redex
+            const func = await loadTerm(collection, term.func);
+            if (func && isAbs(func)) {
+                // This is a redex!
+                return Maybe.just(termHash);
+            }
+            // Not a redex - search in func first (leftmost), then arg
+            const funcRedex = await findRedexNormalOrder(collection, term.func);
+            if (funcRedex.isJust)
+                return funcRedex;
+            return findRedexNormalOrder(collection, term.arg);
+        }
+    }
+}
+/**
+ * Find the leftmost-innermost redex (applicative order reduction)
+ */
+export function findInnermostRedex(collection, termHash) {
+    return IO.of(async () => {
+        return findRedexApplicativeOrder(collection, termHash);
+    });
+}
+async function findRedexApplicativeOrder(collection, termHash) {
+    const term = await loadTerm(collection, termHash);
+    if (!term)
+        return Maybe.nothing();
+    switch (term.tag) {
+        case 'Var':
+            return Maybe.nothing();
+        case 'Abs':
+            return findRedexApplicativeOrder(collection, term.body);
+        case 'App': {
+            // Search in subterms first (innermost)
+            const funcRedex = await findRedexApplicativeOrder(collection, term.func);
+            if (funcRedex.isJust)
+                return funcRedex;
+            const argRedex = await findRedexApplicativeOrder(collection, term.arg);
+            if (argRedex.isJust)
+                return argRedex;
+            // Then check if this is a redex
+            const func = await loadTerm(collection, term.func);
+            if (func && isAbs(func)) {
+                return Maybe.just(termHash);
+            }
+            return Maybe.nothing();
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Beta Reduction
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Perform a single beta reduction step on a redex
+ *
+ * (λx.M) N →β M[x:=N]
+ *
+ * @param collection - Card collection
+ * @param redexHash - Hash of the application term (λx.M) N
+ * @returns Either<error, resultHash>
+ */
+export function betaReduce(collection, redexHash) {
+    return IO.of(async () => {
+        const app = await loadTerm(collection, redexHash);
+        if (!app) {
+            return Either.left(`Term not found: ${redexHash}`);
+        }
+        if (!isApp(app)) {
+            return Either.left(`Beta reduction requires application term, got ${app.tag}`);
+        }
+        const func = await loadTerm(collection, app.func);
+        if (!func) {
+            return Either.left(`Function not found: ${app.func}`);
+        }
+        if (!isAbs(func)) {
+            return Either.left(`Not a beta-redex: function is ${func.tag}, not abstraction`);
+        }
+        // Perform substitution: M[x:=N]
+        const resultHash = await substituteWithCapture(collection, func.body, // M
+        func.param, // x
+        app.arg // N (as hash)
+        );
+        return Either.right(resultHash);
+    });
+}
+/**
+ * Substitute a variable with a term (by hash), handling capture avoidance
+ *
+ * M[x:=N] - replaces all free occurrences of x in M with N
+ */
+async function substituteWithCapture(collection, termHash, variable, replacementHash) {
+    const term = await loadTerm(collection, termHash);
+    if (!term) {
+        throw new Error(`Term not found: ${termHash}`);
+    }
+    switch (term.tag) {
+        case 'Var':
+            // If this is the variable we're substituting, return the replacement
+            if (term.name === variable) {
+                return replacementHash;
+            }
+            // Otherwise unchanged
+            return termHash;
+        case 'Abs': {
+            // If bound variable shadows, stop substitution
+            if (term.param === variable) {
+                return termHash;
+            }
+            // Check for variable capture:
+            // If the bound variable (term.param) is free in the replacement,
+            // we must α-rename to avoid capture
+            const replacementFV = await freeVariables(collection, replacementHash).run();
+            if (replacementFV.isJust && replacementFV.value.has(term.param)) {
+                // Capture would occur! Need to α-rename first
+                const allVars = new Set(replacementFV.value);
+                // Also avoid variables in the body
+                const bodyFV = await freeVariables(collection, term.body).run();
+                if (bodyFV.isJust) {
+                    for (const v of bodyFV.value)
+                        allVars.add(v);
+                }
+                allVars.add(variable);
+                // Generate fresh name
+                const freshName = generateFresh(term.param, allVars);
+                // α-rename the abstraction
+                const renameResult = await alphaRename(collection, termHash, freshName).run();
+                if (renameResult.isLeft) {
+                    throw new Error(`Alpha rename failed: ${renameResult.left}`);
+                }
+                // Now substitute in the renamed term
+                return substituteWithCapture(collection, renameResult.right, variable, replacementHash);
+            }
+            // No capture - recurse into body
+            const newBody = await substituteWithCapture(collection, term.body, variable, replacementHash);
+            if (newBody === term.body) {
+                return termHash;
+            }
+            const newAbs = mkAbs(term.param, newBody);
+            return storeTerm(collection, newAbs);
+        }
+        case 'App': {
+            const newFunc = await substituteWithCapture(collection, term.func, variable, replacementHash);
+            const newArg = await substituteWithCapture(collection, term.arg, variable, replacementHash);
+            if (newFunc === term.func && newArg === term.arg) {
+                return termHash;
+            }
+            const newApp = mkApp(newFunc, newArg);
+            return storeTerm(collection, newApp);
+        }
+    }
+}
+/**
+ * Perform one reduction step using the specified strategy
+ */
+export function reduceStep(collection, termHash, strategy = 'normal') {
+    return IO.of(async () => {
+        // Find redex using strategy
+        let redexMaybe;
+        switch (strategy) {
+            case 'normal':
+            case 'lazy':
+                redexMaybe = await findRedexNormalOrder(collection, termHash);
+                break;
+            case 'applicative':
+                redexMaybe = await findRedexApplicativeOrder(collection, termHash);
+                break;
+        }
+        if (redexMaybe.isNothing) {
+            // No redex found - already in normal form
+            return Maybe.nothing();
+        }
+        const redexHash = redexMaybe.value;
+        // If the redex is the whole term, just reduce it
+        if (redexHash === termHash) {
+            const result = await betaReduce(collection, redexHash).run();
+            if (result.isLeft) {
+                throw new Error(result.left);
+            }
+            return Maybe.just(result.right);
+        }
+        // Otherwise, need to reduce the subterm and reconstruct
+        const reduced = await betaReduce(collection, redexHash).run();
+        if (reduced.isLeft) {
+            throw new Error(reduced.left);
+        }
+        const rebuilt = await rebuildWithReduced(collection, termHash, redexHash, reduced.right);
+        return Maybe.just(rebuilt);
+    });
+}
+/**
+ * Rebuild a term after reducing a subterm
+ */
+async function rebuildWithReduced(collection, termHash, redexHash, reducedHash) {
+    if (termHash === redexHash) {
+        return reducedHash;
+    }
+    const term = await loadTerm(collection, termHash);
+    if (!term)
+        throw new Error(`Term not found: ${termHash}`);
+    switch (term.tag) {
+        case 'Var':
+            return termHash;
+        case 'Abs': {
+            const newBody = await rebuildWithReduced(collection, term.body, redexHash, reducedHash);
+            if (newBody === term.body)
+                return termHash;
+            const newAbs = mkAbs(term.param, newBody);
+            return storeTerm(collection, newAbs);
+        }
+        case 'App': {
+            const newFunc = await rebuildWithReduced(collection, term.func, redexHash, reducedHash);
+            const newArg = await rebuildWithReduced(collection, term.arg, redexHash, reducedHash);
+            if (newFunc === term.func && newArg === term.arg)
+                return termHash;
+            const newApp = mkApp(newFunc, newArg);
+            return storeTerm(collection, newApp);
+        }
+    }
+}
+/**
+ * Normalize a term to its normal form (no more redexes)
+ *
+ * @param collection - Card collection
+ * @param termHash - Starting term
+ * @param strategy - Reduction strategy
+ * @param maxSteps - Maximum reduction steps (prevent infinite loops)
+ * @returns Either<error, NormalizationResult>
+ */
+export function normalize(collection, termHash, strategy = 'normal', maxSteps = 1000) {
+    return IO.of(async () => {
+        let current = termHash;
+        let steps = 0;
+        const path = [termHash];
+        while (steps < maxSteps) {
+            const stepResult = await reduceStep(collection, current, strategy).run();
+            if (stepResult.isNothing) {
+                // No more reductions - reached normal form
+                return Either.right({
+                    normalForm: current,
+                    steps,
+                    reductionPath: path
+                });
+            }
+            current = stepResult.value;
+            path.push(current);
+            steps++;
+        }
+        return Either.left(`Normalization did not terminate within ${maxSteps} steps (possible infinite loop)`);
+    });
+}
+/**
+ * Check if a term is in normal form (has no redexes)
+ */
+export function isNormalForm(collection, termHash) {
+    return findLeftmostRedex(collection, termHash).map(m => m.isNothing);
+}
+/**
+ * Check if a term has a normal form (is normalizing)
+ *
+ * Note: This is undecidable in general, so we use a bounded check
+ */
+export function hasNormalForm(collection, termHash, maxSteps = 1000) {
+    return normalize(collection, termHash, 'normal', maxSteps)
+        .map(result => result.isRight);
+}
+//# sourceMappingURL=BetaReduction.js.map

package/dist/ptr/lambda/BetaReduction.js.map

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

package/dist/ptr/lambda/EtaConversion.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Eta Conversion (η-conversion)
+ *
+ * Captures extensional equality of functions.
+ *
+ * η-reduction: λx.(f x) →η f  (if x ∉ FV(f))
+ * η-expansion: f →η λx.(f x)  (where x is fresh)
+ *
+ * Two functions are η-equivalent if they produce the same output for all inputs.
+ * This is the principle of extensionality: functions are determined by their behavior.
+ *
+ * @module mcard-js/ptr/lambda/EtaConversion
+ */
+import { CardCollection } from '../../model/CardCollection';
+import { IO } from '../../monads/IO';
+import { Either } from '../../monads/Either';
+import { Maybe } from '../../monads/Maybe';
+/**
+ * Check if a term is an η-redex: λx.(f x) where x ∉ FV(f)
+ */
+export declare function isEtaRedex(collection: CardCollection, termHash: string): IO<boolean>;
+/**
+ * Eta reduction: λx.(f x) →η f
+ *
+ * Only valid if x does not occur free in f.
+ *
+ * @param collection - Card collection
+ * @param termHash - Hash of the abstraction λx.(f x)
+ * @returns Maybe<resultHash> - Nothing if not an η-redex
+ */
+export declare function etaReduce(collection: CardCollection, termHash: string): IO<Maybe<string>>;
+/**
+ * Try eta reduction, returning Either for error handling
+ */
+export declare function etaReduceE(collection: CardCollection, termHash: string): IO<Either<string, string>>;
+/**
+ * Eta expansion: f →η λx.(f x)
+ *
+ * Wraps a function in a lambda that immediately applies it.
+ * The new variable must be fresh (not occurring in f).
+ *
+ * @param collection - Card collection
+ * @param termHash - Hash of the term to expand
+ * @param baseName - Base name for the fresh variable (default: 'x')
+ * @returns Hash of the expanded term λx.(f x)
+ */
+export declare function etaExpand(collection: CardCollection, termHash: string, baseName?: string): IO<string>;
+/**
+ * Check if two terms are η-equivalent
+ *
+ * Two terms f and g are η-equivalent if:
+ * - They are the same, or
+ * - One η-reduces to the other, or
+ * - They both η-expand to equivalent terms
+ */
+export declare function etaEquivalent(collection: CardCollection, hash1: string, hash2: string): IO<boolean>;
+/**
+ * Eta-normalize a term by reducing all η-redexes
+ */
+export declare function etaNormalize(collection: CardCollection, termHash: string): IO<string>;
+/**
+ * Find all η-redexes in a term
+ */
+export declare function findEtaRedexes(collection: CardCollection, termHash: string): IO<string[]>;
+//# sourceMappingURL=EtaConversion.d.ts.map

package/dist/ptr/lambda/EtaConversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EtaConversion.d.ts","sourceRoot":"","sources":["../../../src/ptr/lambda/EtaConversion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAa5D,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAM3C;;GAEG;AACH,wBAAgB,UAAU,CACtB,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,GACjB,EAAE,CAAC,OAAO,CAAC,CAkBb;AAMD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACrB,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,GACjB,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAiCnB;AAED;;GAEG;AACH,wBAAgB,UAAU,CACtB,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,GACjB,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAO5B;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CACrB,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,EAChB,QAAQ,GAAE,MAAY,GACvB,EAAE,CAAC,MAAM,CAAC,CAmBZ;AAMD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CACzB,UAAU,EAAE,cAAc,EAC1B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACd,EAAE,CAAC,OAAO,CAAC,CAWb;AAgDD;;GAEG;AACH,wBAAgB,YAAY,CACxB,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,GACjB,EAAE,CAAC,MAAM,CAAC,CAEZ;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC1B,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,GACjB,EAAE,CAAC,MAAM,EAAE,CAAC,CAMd"}

package/dist/ptr/lambda/EtaConversion.js

@@ -0,0 +1,228 @@
+/**
+ * Eta Conversion (η-conversion)
+ *
+ * Captures extensional equality of functions.
+ *
+ * η-reduction: λx.(f x) →η f  (if x ∉ FV(f))
+ * η-expansion: f →η λx.(f x)  (where x is fresh)
+ *
+ * Two functions are η-equivalent if they produce the same output for all inputs.
+ * This is the principle of extensionality: functions are determined by their behavior.
+ *
+ * @module mcard-js/ptr/lambda/EtaConversion
+ */
+import { loadTerm, storeTerm, mkVar, mkAbs, mkApp, isVar, isAbs, isApp } from './LambdaTerm';
+import { freeVariables, generateFreshFor } from './FreeVariables';
+import { IO } from '../../monads/IO';
+import { Either } from '../../monads/Either';
+import { Maybe } from '../../monads/Maybe';
+// ─────────────────────────────────────────────────────────────────────────────
+// Eta Redex Detection
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Check if a term is an η-redex: λx.(f x) where x ∉ FV(f)
+ */
+export function isEtaRedex(collection, termHash) {
+    return IO.of(async () => {
+        const term = await loadTerm(collection, termHash);
+        if (!term || !isAbs(term))
+            return false;
+        const body = await loadTerm(collection, term.body);
+        if (!body || !isApp(body))
+            return false;
+        // Check if argument is the bound variable
+        const arg = await loadTerm(collection, body.arg);
+        if (!arg || !isVar(arg) || arg.name !== term.param)
+            return false;
+        // Check if x is not free in f
+        const funcFV = await freeVariables(collection, body.func).run();
+        if (funcFV.isNothing)
+            return false;
+        return !funcFV.value.has(term.param);
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Eta Reduction
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Eta reduction: λx.(f x) →η f
+ *
+ * Only valid if x does not occur free in f.
+ *
+ * @param collection - Card collection
+ * @param termHash - Hash of the abstraction λx.(f x)
+ * @returns Maybe<resultHash> - Nothing if not an η-redex
+ */
+export function etaReduce(collection, termHash) {
+    return IO.of(async () => {
+        const term = await loadTerm(collection, termHash);
+        if (!term)
+            return Maybe.nothing();
+        // Must be λx.E
+        if (!isAbs(term))
+            return Maybe.nothing();
+        const body = await loadTerm(collection, term.body);
+        if (!body)
+            return Maybe.nothing();
+        // Body must be application (f x)
+        if (!isApp(body))
+            return Maybe.nothing();
+        // Argument must be the bound variable
+        const arg = await loadTerm(collection, body.arg);
+        if (!arg)
+            return Maybe.nothing();
+        if (!isVar(arg) || arg.name !== term.param) {
+            return Maybe.nothing();
+        }
+        // x must not be free in f
+        const funcFV = await freeVariables(collection, body.func).run();
+        if (funcFV.isNothing)
+            return Maybe.nothing();
+        if (funcFV.value.has(term.param)) {
+            return Maybe.nothing();
+        }
+        // η-reduce: return f's hash
+        return Maybe.just(body.func);
+    });
+}
+/**
+ * Try eta reduction, returning Either for error handling
+ */
+export function etaReduceE(collection, termHash) {
+    return etaReduce(collection, termHash).map(maybe => {
+        if (maybe.isNothing) {
+            return Either.left('Not an η-redex');
+        }
+        return Either.right(maybe.value);
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Eta Expansion
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Eta expansion: f →η λx.(f x)
+ *
+ * Wraps a function in a lambda that immediately applies it.
+ * The new variable must be fresh (not occurring in f).
+ *
+ * @param collection - Card collection
+ * @param termHash - Hash of the term to expand
+ * @param baseName - Base name for the fresh variable (default: 'x')
+ * @returns Hash of the expanded term λx.(f x)
+ */
+export function etaExpand(collection, termHash, baseName = 'x') {
+    return IO.of(async () => {
+        // Generate fresh variable name
+        const freshVar = await generateFreshFor(collection, baseName, termHash);
+        // Create variable term
+        const varTerm = mkVar(freshVar);
+        const varHash = await storeTerm(collection, varTerm);
+        // Create application (f x)
+        const appTerm = mkApp(termHash, varHash);
+        const appHash = await storeTerm(collection, appTerm);
+        // Create abstraction λx.(f x)
+        const absTerm = mkAbs(freshVar, appHash);
+        const absHash = await storeTerm(collection, absTerm);
+        return absHash;
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Eta Equivalence
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Check if two terms are η-equivalent
+ *
+ * Two terms f and g are η-equivalent if:
+ * - They are the same, or
+ * - One η-reduces to the other, or
+ * - They both η-expand to equivalent terms
+ */
+export function etaEquivalent(collection, hash1, hash2) {
+    return IO.of(async () => {
+        // Same hash = definitely equivalent
+        if (hash1 === hash2)
+            return true;
+        // Try reducing both to see if they meet
+        const reduced1 = await etaReduceDeep(collection, hash1);
+        const reduced2 = await etaReduceDeep(collection, hash2);
+        return reduced1 === reduced2;
+    });
+}
+/**
+ * Recursively apply η-reduction until no more η-redexes
+ */
+async function etaReduceDeep(collection, termHash) {
+    const term = await loadTerm(collection, termHash);
+    if (!term)
+        return termHash;
+    switch (term.tag) {
+        case 'Var':
+            return termHash;
+        case 'Abs': {
+            // First try η-reduction at this level
+            const etaResult = await etaReduce(collection, termHash).run();
+            if (etaResult.isJust) {
+                // η-reduced - continue reducing the result
+                return etaReduceDeep(collection, etaResult.value);
+            }
+            // Not an η-redex - recurse into body
+            const newBody = await etaReduceDeep(collection, term.body);
+            if (newBody === term.body)
+                return termHash;
+            const newAbs = mkAbs(term.param, newBody);
+            return storeTerm(collection, newAbs);
+        }
+        case 'App': {
+            const newFunc = await etaReduceDeep(collection, term.func);
+            const newArg = await etaReduceDeep(collection, term.arg);
+            if (newFunc === term.func && newArg === term.arg)
+                return termHash;
+            const newApp = mkApp(newFunc, newArg);
+            return storeTerm(collection, newApp);
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Combined Eta Operations
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Eta-normalize a term by reducing all η-redexes
+ */
+export function etaNormalize(collection, termHash) {
+    return IO.of(() => etaReduceDeep(collection, termHash));
+}
+/**
+ * Find all η-redexes in a term
+ */
+export function findEtaRedexes(collection, termHash) {
+    return IO.of(async () => {
+        const redexes = [];
+        await collectEtaRedexes(collection, termHash, redexes);
+        return redexes;
+    });
+}
+async function collectEtaRedexes(collection, termHash, redexes) {
+    const term = await loadTerm(collection, termHash);
+    if (!term)
+        return;
+    switch (term.tag) {
+        case 'Var':
+            break;
+        case 'Abs': {
+            // Check if this is an η-redex
+            const isRedex = await isEtaRedex(collection, termHash).run();
+            if (isRedex) {
+                redexes.push(termHash);
+            }
+            // Also check body
+            await collectEtaRedexes(collection, term.body, redexes);
+            break;
+        }
+        case 'App': {
+            await collectEtaRedexes(collection, term.func, redexes);
+            await collectEtaRedexes(collection, term.arg, redexes);
+            break;
+        }
+    }
+}
+//# sourceMappingURL=EtaConversion.js.map

package/dist/ptr/lambda/EtaConversion.js.map

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