如何在Java中实现函子的不动点

Question

我最近发现了如何在Java中以某种迂回的方式模拟更高级的类型

interface H<F, T> { }

这里，H编码一种更高级的类型，该类型采用类型参数F，其本身采用参数T。

现在这让我想知道，我们可以用它来实现一些更高级的构造吗？例如，Haskell中Fix之类的函子的不动点及其对应的反态？

Answer 1

事实上，这可以通过仔细翻译相应的Haskell副本来实现。尽管这会引入大量线路噪声，但其实现与最初的非常接近：

// Encoding of higher kinded type F of T
public interface H<F, T> { }

public interface Functor<F, T> {
    <R> H<F, R> map(Function<T, R> f);
}

// newtype Fix f = Fix {unfix::f (Fix f)}
public static record Fix<F extends H<F, T> & Functor<F, T>, T>(F f) {
    public Functor<F, Fix<F, T>> unfix() {
        return (Functor<F, Fix<F, T>>) f;
    }
}

// type Algebra f a = f a -> a
public interface Algebra<F, T> extends Function<H<F, T>, T> {}

 // cata :: Functor f => Algebra f a -> Fix f -> a
 // cata alg = alg . fmap (cata alg) . unfix
public static <F extends H<F, T> & Functor<F, T>, T> Function<Fix<F, T>, T> cata(Algebra<F, T> alg) {
    return fix -> alg.apply(fix.unfix().map(cata(alg)));
}

令人惊讶的是，这是可行的，可以用来实现表达式代数的解释器

// evalExprF :: Algebra ExprF Int
// evalExprF (Const n) = n
// evalExprF (Add m n) = m + n
// evalExprF (Mul m n) = m * n
public static class ExprAlg implements Algebra<Expr, Integer> {
    @Override
    public Integer apply(H<Expr, Integer> hExpr) {
        return Expr.expr(hExpr).match(
            conzt -> conzt.n,
            add   -> add.t1 + add.t2,
            mul   -> mul.t1 * mul.t2);
    }
}

我的GitHub存储库中的完整工作示例。