使用Java 8的Monads [英] Monads with Java 8

问题描述

为了帮助理解monad是什么，有人可以提供一个使用java的例子吗？它们是否可能？

In the interests of helping to understand what a monad is, can someone provide an example using java ? Are they possible ?

如果你从这里下载预发布的lambda兼容JDK8 http://jdk8.java.net/lambda/

Lambda expressions are possible using java if you download the pre-release lambda compatible JDK8 from here http://jdk8.java.net/lambda/

使用此JDK的lambda示例如下所示，有人可以提供一个相对简单的monad吗？

An example of a lambda using this JDK is shown below, can someone provide a comparably simple monad ?

public interface TransformService {
        int[] transform(List<Integer> inputs);
    }
    public static void main(String ars[]) {
        TransformService transformService = (inputs) -> {
            int[] ints = new int[inputs.size()];
            int i = 0;
            for (Integer element : inputs) {
                ints[i] = element;
            }
            return ints;
        };

        List<Integer> inputs = new ArrayList<Integer>(5) {{
            add(10);
            add(10);
        }};
        int[] results = transformService.transform(inputs);
    }

推荐答案

仅供参考：

建议的 JDK8可选 class 确实满足三个 Monad法律。这是一个要点证明。

The proposed JDK8 Optional class does satisfy the three Monad laws. Here's a gist demonstrating that.

所有Monad都需要提供符合三个法律的两个函数。

All it takes be a Monad is to provide two functions which conform to three laws.

两个函数：

1. 将值放入monadic上下文

• Haskell的可能：返回 / 只需


• Scala的选项：一些


• 功能Java的选项： Option.some


• JDK8的可选： Optional.of

• Haskell's Maybe: return / Just
• Scala's Option: Some
• Functional Java's Option: Option.some
• JDK8's Optional: Optional.of

在monadic context中应用函数

Apply a function in monadic context

• Haskell的可能：>> = （又名 bind ）


• Scala的选项： flatMap


• 功能Java的选项： flatMap


• JDK8的可选： flatMap

• Haskell's Maybe: >>= (aka bind)
• Scala's Option: flatMap
• Functional Java's Option: flatMap
• JDK8's Optional: flatMap

请参阅上面的要点用于三个法则的java演示。

Please see the above gist for a java demonstration of the three laws.

注意：要理解的关键事项之一是要在monadic context 中应用的函数的签名：它采用原始值类型，并返回monadic类型。

NOTE: One of the key things to understand is the signature of the function to apply in monadic context: it takes the raw value type, and returns the monadic type.

换句话说，如果你有一个 Optional< Integer> 的实例，你可以传递给它的函数 flatMap 方法将具有签名（整数） - >可选< U> ，其中 U 是一种值类型，不必是整数，例如 String ：

In other words, if you have an instance of Optional<Integer>, the functions you can pass to its flatMap method will have the signature (Integer) -> Optional<U>, where U is a value type which does not have to be Integer, for example String:

Optional<Integer> maybeInteger = Optional.of(1);

// Function that takes Integer and returns Optional<Integer>
Optional<Integer> maybePlusOne = maybeInteger.flatMap(n -> Optional.of(n + 1));

// Function that takes Integer and returns Optional<String>
Optional<String> maybeString = maybePlusOne.flatMap(n -> Optional.of(n.toString));

您不需要任何类型的Monad接口来编码，或者这样思考。在Scala中，您不编码为Monad接口（除非您使用的是Scalaz库...）。似乎JDK8也将使Java人员能够使用这种链式monadic计算。

You don't need any sort of Monad Interface to code this way, or to think this way. In Scala, you don't code to a Monad Interface (unless you are using Scalaz library...). It appears that JDK8 will empower Java folks to use this style of chained monadic computations as well.

希望这有用！

更新：有关此内容的博客 here 。

这篇关于使用Java 8的Monads的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！