Java 在这个应用程序函子的定义中，get（）和unit（）是什么？

我试图用java编写一些函子、单子和应用程序。我找到了一些，并选择了下面的一个

在范畴理论中，什么是get（）

abstract class Functor6<F,T> {
    protected abstract <U> Function<? extends Functor6<F,T>,? extends Functor6<?,U>> fmap(Function<T,U> f);
}

abstract class Applicative<F,T>extends Functor6<F,T> {
    public abstract <U> U get(); // what is this in terms of category theory?

    protected abstract <U> Applicative<?,U> unit(U value); // what is this in terms of category theory?

    protected final <U> Function<Applicative<F,T>,Applicative<?,U>> apply(final Applicative<Function<T,U>,U> ff) {
        return new Function<Applicative<F,T>,Applicative<?,U>>() {
            public Applicative<?,U> apply(Applicative<F,T> ft) {
                Function<T,U> f=ff.get();
                T t=ft.get();
                return unit(f.apply(t));
            }
        };
    }
}

unit（）看起来像某种身份，但从什么到什么？或者这是一个构造函数

我看到了一个有get（）的函子定义。这会是什么

abstract class Functor6<F,T> {
    protected abstract <U> Function<? extends Functor6<F,T>,? extends Functor6<?,U>> fmap(Function<T,U> f);
}

abstract class Applicative<F,T>extends Functor6<F,T> {
    public abstract <U> U get(); // what is this in terms of category theory?

    protected abstract <U> Applicative<?,U> unit(U value); // what is this in terms of category theory?

    protected final <U> Function<Applicative<F,T>,Applicative<?,U>> apply(final Applicative<Function<T,U>,U> ff) {
        return new Function<Applicative<F,T>,Applicative<?,U>>() {
            public Applicative<?,U> apply(Applicative<F,T> ft) {
                Function<T,U> f=ff.get();
                T t=ft.get();
                return unit(f.apply(t));
            }
        };
    }
}

抽象类functor 6{
受保护的抽象函数一些Haskell可能会有所帮助。首先，一个函子：

class Functor f where
    fmap :: (a -> b) -> f a -> f b

我们可以这样理解，如果一个类型
f
是一个
Functor
，那么就必须有一个
fmap
函数，它接受一个类型
a->b
的函数和一个类型
fa
的值，以产生一个
fb
。也就是说，该类型允许将函数应用于其中的值

Java不支持更高种类的类型，定义上述函子类型需要更高种类的类型，因此我们必须对其进行近似：

interface Functor6<F, T> {
    <U> Function<? extends Functor6<F, T>, ? extends Functor6<?, U>> fmap(Function<T, U> f);
}

也就是说，类型
f
要成为应用程序，它必须是一个函子，有一个
pure
操作将值提升到应用程序
f
，还有一个apply操作（
），该操作给定一个函数（
a->b
）在
f
内部和
f
内部的
a
内部，可以将函数应用于值，以在
f
内部生成a
b

以下是您的Java等价物，使用一些Java 8功能进行了简化，并更正了一些类型：

interface Applicative<F, T> extends Functor6<F, T> {
    T get();

    <F, U> Applicative<F, U> unit(U value);

    default <U> Function<Applicative<F, T>, Applicative<F, U>> apply(Applicative<?, Function<T, U>> ff) {
        return ft -> {
            Function<T, U> f = ff.get();
            T t = ft.get();
            return unit(f.apply(t));
        };
    }
}

似乎是访问应用程序中的值的一种方法。这可能适用于特定情况，但不适用于一般情况。这：

    <F, U> Applicative<F, U> unit(U value);

应用单位（U值）；

应该与Haskell定义中的
pure
函数等效。它应该是静态的，否则您需要一个应用程序值才能调用它，但是将其设置为静态将防止在实际应用程序实现中重写它。在Java中没有简单的方法来解决这个问题

然后你有了
apply
方法，根据权利，它应该等同于Haskell中的
。我们可以看到，它只是从应用程序中获取函数
f
，然后是它的参数，并返回一个包含将函数应用到参数的结果的应用程序

这才是真正的关键所在。应用程序如何将函数应用于值的细节是每个应用程序特有的，不能像这样概括

简而言之，这种方法是错误的。这并不是说你不能在Java中实现应用程序函子——你可以，而且很容易，但你不能在语言中声明它们是应用程序，就像你在Haskell（使用类型类）中所做的那样。
一些Haskell可能会有所帮助。首先，函子：

class Functor f where
    fmap :: (a -> b) -> f a -> f b

我们可以这样理解，如果一个类型
f
是一个
Functor
，那么就必须有一个
fmap
函数，它接受一个类型
a->b
的函数和一个类型
fa
的值，以产生一个
fb
。也就是说，该类型允许将函数应用于其中的值

Java不支持更高种类的类型，定义上述函子类型需要更高种类的类型，因此我们必须对其进行近似：

interface Functor6<F, T> {
    <U> Function<? extends Functor6<F, T>, ? extends Functor6<?, U>> fmap(Function<T, U> f);
}

也就是说，类型
f
要成为应用程序，它必须是一个函子，有一个
pure
操作将值提升到应用程序
f
，还有一个apply操作（
），该操作给定一个函数（
a->b
）在
f
内部和
f
内部的
a
内部，可以将函数应用于值，以在
f
内部生成a
b

以下是您的Java等价物，使用一些Java 8功能进行了简化，并更正了一些类型：

interface Applicative<F, T> extends Functor6<F, T> {
    T get();

    <F, U> Applicative<F, U> unit(U value);

    default <U> Function<Applicative<F, T>, Applicative<F, U>> apply(Applicative<?, Function<T, U>> ff) {
        return ft -> {
            Function<T, U> f = ff.get();
            T t = ft.get();
            return unit(f.apply(t));
        };
    }
}

似乎是访问应用程序中的值的一种方法。这可能适用于特定情况，但不适用于一般情况。这：

    <F, U> Applicative<F, U> unit(U value);

应用单位（U值）；

应该与Haskell定义中的
pure
函数等效。它应该是静态的，否则您需要一个应用程序值才能调用它，但是将其设置为静态将防止在实际应用程序实现中重写它。在Java中没有简单的方法来解决这个问题

然后你有了
apply
方法，根据权利，它应该等同于Haskell中的
。我们可以看到，它只是从应用程序中获取函数
f
，然后是它的参数，并返回一个包含将函数应用到参数的结果的应用程序

这才是真正的关键所在。应用程序如何将函数应用于值的细节是每个应用程序特有的，不能像这样概括

简而言之，这种方法是错误的。这并不是说你不能在Java中实现应用程序函子——你可以，而且很容易，但是你不能在语言中声明它们是应用程序，就像你在Haskell（使用类型类）中所做的那样