java - 这是一个 monad(在 Java 中)吗？

Question

在我四处宣扬我已经成功之前，我想问一下。请不要犹豫，我想先在这里接受任何批评。

由于 Java 缺乏动态语言在传递任意参数方面的灵 active ，我通过将所有可能的输入捆绑到一个类(People)中来弥补，该类形成了输入空间。这些函数在 monad 的帮助下将其映射到输出空间(Friends)。

我不是要解决一般情况，只是想出一个例子，看看我是否理解设计模式。

monad(如果是这样的话)执行这些规则:一旦邀请被拒绝，或者出现错误，就不会再进行进一步的处理。

抱歉篇幅过长。毕竟是Java。为了节省空间，我采用了一些约定俗成的捷径。

这实际上是一个 monad 的例子吗？ (封装在Friends类中)

public class Sample {
    public static void main(String[] args) {
        People people0 = new People("Bob", "Fred");
        Friends friends0 = Friends.pipeline(people0, ToFromFunction.INVITE, ToFromFunction.ACCEPT);
        System.err.println(friends0);

        People people1 = new People("Bob", "Jenny");
        Friends friends1 = Friends.pipeline(people1, ToFromFunction.INVITE, ToFromFunction.ACCEPT);
        System.err.println(friends1);

        People people2 = new People("Bob", "Fred");
        Friends friends2 = Friends.pipeline(people2, ToFromFunction.INVITE, ToFromFunction.BLOCK);
        System.err.println(friends2);
    }
}

/** this is the space of all inputs */
public class People {
    public People(String from, String to) {
        this.from = from;
        this.to = to;
    }

    public String from;
    public String to;
}

/** this is the output space, and the monad (?) */
public class Friends {

    public boolean friends = false;
    public boolean rejected = false;
    public String errors = "";

    public static Friends unit(People from) {
        return new Friends();
    }

    public Friends bind(ToFromFunction f, People from) {
        if (! errors.isEmpty()) {
            // we have errors; skip the rest
            return this;
        }

        if (rejected) {
            // No means no
            return this;
        }

        return f.act(from, this);
    }

    public static Friends pipeline(People from, ToFromFunction... functions) {
        Friends result = Friends.unit(from);
        for (ToFromFunction f : functions) {
            result = result.bind(f, from);
        }
        return result;
    }
}

/** functions from People to Friends */
public interface ToFromFunction {

    Friends act(People from, Friends to);

    ToFromFunction INVITE = new ToFromFunction() {
        public Friends act(People from, Friends to) {
            // Jenny has blocked Bob
            if ("Jenny".equals(from.to) && "Bob".equals(from.from)) {
                to.errors = "Jenny blocked Bob";
            }
            return to;
        }
    };

    ToFromFunction ACCEPT = new ToFromFunction() {
        public Friends act(People from, Friends to) {
            // Good to go!
            to.friends = true;
            return to;
        }
    };

    ToFromFunction BLOCK = new ToFromFunction() {
        public Friends act(People from, Friends to) {
            to.friends = false;
            to.rejected = true;
            return to;
        }
    };
}

Answer 1

Monad 是类型，它实现了两个具有固定签名的函数:unit 和 bind。

在 Haskell 中:

unit :: a -> m a

bind :: m a -> (a -> m b) -> m b

unit包装类型为 a 的对象进入 m类型 a . a 的类型必须是任意的。实现bind可以是任何东西(但必须满足一元律)。

让我们尝试将您的示例转换为 Haskell 语法:

人只是一个元组:

type People = (String, String)

Friends 的类型是两个 boolean 值和一个字符串的三元组。

如果我们使用这些类型，那么您的 Friends.unit 方法是这样的:

unit_friends :: People -> Friends
unit_friends _ = (false, false)

也就是说，unit_friends正在丢弃 is 参数并返回 Friends 的新实例.这是 unit 的错误类型签名.相反，单元应该有这样的类型签名:

unit_friends :: a -> Friends a

在 Java 中，这应该类似于:

public static Friends<T> unit(T from) {
    // return something of type Friends<T>
}

你的 bind函数采用 ToFromFunction 类型的函数和一个 People 类型的对象并返回 Friends 类型的东西:

bind_friends :: ToFromFunction -> People -> Friends

让我们替换ToFromFunction与

type ToFromFunction = People -> Friends -> Friends

因为这是 act 的类型签名.

bind_friends :: (People -> Friends -> Friends) -> People -> Friends

让我们翻转 bind_friends 的参数，因为 lambda 函数应该是第二个参数:

bind_friends :: People -> (People -> Friends -> Friends) -> Friends

但它应该有这样的类型签名:

bind_friends :: Friends a -> (a -> Friends b) -> Friends b

您的单元和绑定(bind)类型与真正的 monad 不匹配，但有点接近。

让我们暂时忘记我们需要一个任意类型 a。 bind_friends的第一个参数必须是 Friends 类型, 不是 People 类型，因为 bind应该解除ToFromFunction到 Friends单子(monad)。