functional-programming - Java 8 monad 中的流是什么？

Question

Java 8 中的 Optional似乎是一个 monad 。

Streams 也是单子吗？

任何人都可以识别可选单子中的内函子和两个自然变换吗？

Answer 1

编辑下面的答案是不正确的（保留在这里作为历史记录）。

是的，在每种情况下，仿函数都由类及其map方法组成，两个自然变换是of和flatMap(identity)。

正确的答案似乎就在这里。

Answer 2

是的，java.util.stream.Stream满足单子定律。

以下先决条件是：

1. Stream应该是Functor，即提供以下功能fmap :: (a -> b) -> M a -> M b。如果我们查看来源，我们会发现它已经具有功能Stream<R> map(Function<T, R> mapper)

2. 它应该有unit（又名return）操作：unit :: a -> M a. 这一点很明显：Stream<T> of(T t).

3. 它应该有bind 或 join操作：

   1. bind :: M a -> (a -> M b) -> M b：Stream<R> flatMap(Function<T, Stream<R>> mapper)
   2. join :: M (M a) -> M a：这个不存在，Stream但我们可以从中推断出来bind。

现在我们有了所需的功能。但仅仅称它为 monad 还不够！我们需要证明单子定律是有效的。让我们看看它们：

左身份： (return a) bind f <=> f a

        Function<String, Stream<Integer>> f = str -> str.chars().boxed();
        String a = "abc";
        Stream<Integer> left = Stream.of(a).flatMap(f);
        Stream<Integer> right = f.apply(a);
        //left should be same as right

正确身份： m bind unit <=> m

        Stream<String> stream = Stream.of("abc", "def");
        Stream<String> left = stream.flatMap(str -> Stream.of(str));
        // left should be same as Stream.of("abc", "def")

关联性： (m bind f) bind g <=> m bind (\x -> f x bind g)

        Function<Integer, Stream<String>> f = integer -> Arrays.stream(Integer.toHexString(integer).split(""));
        Function<String, Stream<BigInteger>> g = string -> Stream.of(string).map(str -> new BigInteger(str, 16));

        Stream<Integer> mLeft = Stream.of(47789, 61453);
        Stream<BigInteger> left = mLeft.flatMap(f).flatMap(g);

        Stream<Integer> mRight = Stream.of(47789, 61453);
        Stream<BigInteger> right = mRight.flatMap(integer -> f.apply(integer).flatMap(g));
        //left should be same as right        

所以看起来 Streams 真的是单子！但要小心，可能会发生与Optional有时违反一元法则相同的情况。我有一种直觉，如果你使用它，在某些情况下可能会违反它，parallel()因为它可以改变执行顺序。如果你知道它可能发生在哪里，请在下面评论。

Answer 3

如果您知道 Haskell：Java 的 Stream 就是其他东西，那么 Haskell 的 list monad [] 和 Java 的 Optional 就是 Haskell 的 Maybe monad。