什么是单子？Java 开发人员的基本理论

monad 是一个源自数学的一部分的概念，称为 范畴论，而不是类或特征。在本文中，我将尝试解释它的结构和内部工作原理。通过使用 JAVA 中的Optional ，我将尝试以更易于理解的方式描述所有这些。我还将实现一个基本的 monad 以更好地理解它们的工作原理，并以一个简短的使用示例作为结尾，以展示 monad 相对于非 monad 方法的优势。

为什么要学习 Monads 是如何工作的？

首先，对我们使用的东西如何工作有一个基本的了解总是好的。如果您是 Java 开发人员，您可能会使用 monad，甚至可能不知道。这可能会让您感到惊讶，但Java 8 最著名的两个特性，即Stream和Optional是 monad 实现。

让我们从描述什么是 monad 开始——或多或少准确。在我看来，这里的问题相当简单。

Monad 只是内函子范畴中的一个幺半群

基于 Saunders mac Lane 的 “工作数学家分类”中的 一句话 。

回到认真...

什么是单子？

阅读介绍后，您知道 monad 是范畴论中的一个概念。在软件世界中，它可以在任何具有泛型支持的静态类型语言中实现为类或特征。此外，我们可以将其视为一个包装器，将我们的值放在某个上下文中，并允许我们对值执行操作，特别是返回包装在同一上下文中的值的操作。此外，我们可以以这样一种方式链接操作，即任何步骤的操作的输出都是下一步操作的输入。

现代编程语言中的单子示例：

流（Java）。

可选/选项（Java/Scala）。

要么（斯卡拉）。

尝试（规模）。

IO Monad（哈斯克尔）。

单子定律

在谈到 monad 时，最后需要提及的是它们的法则。如果我们想将我们的实现视为一个真正的 monad，我们必须服从它们。存在三个定律：左身份、右身份和关联性。在我看来，理解它们的实际含义可能有些困难。

现在，在Optional的帮助下，我将尝试更详细地解释上述规律。

但首先有几个假设：

f 是从类型 T 到类型 Optional<R> 的函数映射

g 是从类型 R 到类型 Optional<U> 的函数映射

1.左身份

如果我们创建一个新的 monad 并将其绑定到函数，结果应该与将函数应用于值相同。

Optional<String> leftIdentity = Optional.of(x).flatMap(f);Optional<String> mAppedX = f.apply(x);assert leftIdentity.equals(mappedX);

2.正确的身份

将单元函数绑定到 monad 的结果应该与创建新 monad 的结果相同。

Optional<Integer> rightIdentity = Optional.of(x).flatMap(Optional::of);Optional<Integer> wrappedX = Optional.of(x);assert rightIdentity.equals(wrappedX);

3.关联性

在函数应用程序链中，函数如何嵌套并不重要。

Optional<Long> leftSide = Optional.of(x).flatMap(f).flatMap(g);Optional<Long> rightSide = Optional.of(x).flatMap(v -> f.apply(v).flatMap(g));assert leftSide.equals(rightSide);

如果你喜欢阅读 Monads 并想学习类似的相关概念，关注与私信博主
https://docs.qq.com/doc/DQ2Z0eE1aUmlITnNz

单子的创造

现在，当我们了解了基础知识后，我们就可以专注于实施了。

我们需要的第一件事是参数化类型 M<T>，它是类型 T 的值的包装器。我们的类型必须实现两个函数：

of ( unit ) 用于包装我们的值并具有以下签名M<T>(T)。

flatMap ( bind ) 负责执行操作。在这里，我们传递了一个函数，该函数对上下文中的值进行操作，并以已经包装在上下文中的另一种类型返回它。此方法应具有以下签名M<U> (T -> M<U>)。

为了更容易理解，我将再使用一次Optional并展示上面的结构在这种情况下的样子。

在这里，第一个条件立即得到满足，因为Optional是参数化类型。单位函数的作用由ofNullable和of方法完成。FlatMap 起到绑定功能的作用。当然，在Optional的情况下，类型边界允许我们使用比上面定义更复杂的类型。

理论讲完了，我们来实现

import java.util.function.Function; public final class WrapperMonad<T> { private final T value; private WrapperMonad(T value) { this.value = value; } static <T> WrapperMonad<T> of(T value) { return new WrapperMonad<>(value); } <U> WrapperMonad<U> flatMap(Function<T, WrapperMonad<U>> function) { return function.apply(value); } // For sake of asserting in Example boolean valueEquals(T x) { return value.equals(x); } }

等等，monad 实现了。让我们详细描述一下我在这里做了什么。

这里到底发生了什么

我们实现的基础是具有名为“value”的不可变字段的参数化类，它负责存储我们的值。然后，我们有一个私有构造函数，这使得除了通过我们的包装方法 - of之外的任何其他方式都无法创建对象。

接下来，我们有两个基本的 monad 函数，即of（等价于unit）和flatMap（等价于bind），这将保证我们的实现以 monad 法则的形式满足所需条件。

有了所描述的功能，现在是使用示例的时候了。所以就在这里。

import java.util.function.Function; public class Example { public static void mAIn(String[] args) { int x = 2; // Task: performing operation, returning wrapped value, over the value inside the container object. // Non-Monad Function<Integer, Wrapper<String>> toString = i -> new Wrapper<>(i.toString()); Function<String, Wrapper<Integer>> hashCode = str -> new Wrapper<>(str.hashCode()); Wrapper<Integer> wrapper = new Wrapper<>(x); Wrapper<String> stringifyWrapper = toString.apply(wrapper.value); // One liner - Wrapper<Integer> hashCodedWrapper = hashCode.apply(toString.apply(x).value); Wrapper<Integer> hashCodedWrapper = hashCode.apply(stringifyWrapper.value); // Monad Function<Integer, WrapperMonad<String>> toStringM = i -> WrapperMonad.of(i.toString()); Function<String, WrapperMonad<Integer>> hashCodeM = str -> WrapperMonad.of(str.hashCode()); WrapperMonad<Integer> hashCodedWrapperMonadic = WrapperMonad.of(x) .flatMap(toStringM) .flatMap(hashCodeM); assert hashCodedWrapperMonadic.valueEquals(hashCodedWrapper.value); System.out.println("Values inside wrappers are equal"); } }

在上面的代码中，除了看到 monad 是如何工作的，我们还可以看到使用它们的一些优点。

在 monadic 部分，所有操作都组合到一个执行管道中，这使得代码更具声明性，更易于阅读和理解。此外，如果有一天我们决定添加错误处理逻辑，它可以很好地封装在flatMap方法中。

另一方面，在示例的非单子部分中，我们使用包私有字段值进行了不同的设计，我们需要一种从包装器外部访问值的方法，这破坏了封装。就目前而言，该片段足够可读，但您可能会注意到它对扩展不友好。添加任何类型的异常处理都可能使它变得非常意大利面条。

加起来

Monad是一个非常有用且强大的概念，我们中的许多人可能在日常工作中使用它。我试图对其背后的理论基础和逻辑提供清晰和描述性的解释。我实现了一个自定义 monad 以表明它不是一个复杂的结构。在上面的示例中，我展示了 monad 的用法，这种方法的潜在优点是什么，以及它与普通方法调用有何不同。感谢您的时间。

如果您喜欢阅读有关 Monads 的内容并想了解更多有关其他类似概念的信息，关注与私信博主
https://docs.qq.com/doc/DQ2Z0eE1aUmlITnNz免费学习领取JAVA 课件，源码，安装包等资料

关于 Monad 的常见问题

什么是单子？

Monad 是一个概念，起源于称为范畴论的数学部分。

我为什么要关心 Monad？

如果您是 Java 开发人员，您可能每天都在使用 monad，但我可以告诉您有问题。例如，Stream 和 Optional 是 monad 的实现，是最容易混淆的对象。此外，函数式编程变得越来越流行，因此我们可能会期待更多这样的结构。

什么是单子定律？

每个 Monad 实现都必须满足三个定律：左身份、右身份和关联性。

我需要什么来实现 Monad？

要实现 Monad，您需要一个参数化类型 M<T> 和两个方法 unit 和 bind。