对多范式语言有用的 monad

当我理解了 monad 在 c++/python 中的用途后，我终于开始了解 monad 了，它允许您将以下形式的函数链接在一起T -> Generic<U>。例如，如果您有

readfile = [](string s) -> optional<string> {...};
http_request = [](string s) -> optional<int> {...};
inverse = [](int i) -> optional<int> {...}

然后绑定>>= :: optional<T> -> (T -> optional<U>) -> optional<U>具有完全正确的签名以允许您编写这些函数

optional{"myfile"} >>= readfile >>= http_request >>= inverse;
// or in haskell
read_request_inverse = (>>= inverse) . (>>= http_request) . readfile

而不是手动写出短路条件

[]() -> optional<int>
{
    auto message = readfile("myfile");
    if (!message)
        return nullopt
    auto number = http_request(*message)
    if (!number)
        return nullopt
    return inverse(*number)
}

我认为让我困惑的是没有区分链式绑定和嵌套绑定（Bartosz Milewski 演示了 C++ 范围 https://bartoszmilewski.com/2014/10/17/c-ranges-are-pure-monadic-goodness/）并分别理解它们

auto triples =
  for_each(ints(1), [](int z) {
    return for_each(ints(1, z), [=](int x) {
      return for_each(ints(x, z), [=](int y) {
        return yield_if(x*x + y*y == z*z, std::make_tuple(x, y, z));
      });
    });
  });

这只是列表理解

triples = [(x, y, z) | z <- [1..]
                     , x <- [1..z]
                     , y <- [x..z]
                     , x^2 + y^2 == z^2]

另外，我相信我被这样一个事实绊倒了：读者、作者和状态单子只是试图逆向工程副作用（我不完全确定这不会重新引入不纯过程/子例程的问题），所以在多范式语言中没有用处，在多范式语言中您只能产生真正的（合理限制的）副作用。

So monadic optional<T>/result<T,E> seems highly useful in c++/python/rust, and monadic ranges/lists might be useful solving coding challenges but not really for real life problems (edit: I've actually started using flatmap/views::for_each it a lot for simplifying "business logic").

所以我的问题是是否还有其他 monad 的例子可以证明 monad 在多范式语言中的有用性？

充分利用 monad 的编程语言当然是函数式编程语言。您在问题中使用 Haskell，但 monad 在 OCaml 中也很有用。

这种编程模式有用的第一个例子是Nix https://en.wikipedia.org/wiki/Nix_package_manager。 Nix 是一个包管理器，它使用用 nix 编写的脚本（是的，与术语有一些重叠）来描述打包以及其他内容。如果您想知道，是的，nix 是一种纯粹的、惰性的函数式编程语言。它甚至有一个完整的操作系统，其配置是用 nix 编写的，称为NixOS https://en.wikipedia.org/wiki/NixOS。打包应用程序时，单子模式经常出现，尽管方式相当复杂。这个想法是，包本身是 monad，有一个函子，允许您链接包的修改。在伪代码中，保留您的符号，它可能类似于package >>= apply_patch >>= change_version >>= add_tests.

另一个例子是Rust https://www.rust-lang.org/。与 Haskell、OCaml 或 nix 相反，Rust 不是一种函数式编程语言（更多的是一种系统编程语言），但它具有函数式编程语言的许多方面及其许多模式，包括option例如，在 Rust 中，称为Option<T>（通用的T）。除了基本的方法之外，Rust 还提供了几种方法map要处理的函子Option<T>对象，所以典型的 Rust 代码可能看起来像（假设a: Option<T>)

a
  .map(|x| ...)
  .filter(|x| ...)
  .and_then(|x| ...)
  .or_default()

然而，Rust 并不完全像 Haskell 那样处理 monad，因为在 Rust 中，与 monad 兼容的函数（即does_something: fn(U) -> Option<T>）实际上会解压 monad 包含的值，直接对该值进行操作，然后重新包装它们。这很简单?运算符，它只是宏的语法糖（try!一）。用法如下，如果a: Option<T>.

fn do_something_with_a(a: Option<T>) -> Option<U> {
  let b = do_something_with_a_value(a?);
  Some(b)
}

在这里，?运营商首先采取行动match结束a。如果它是一个None，然后函数立即返回None。否则，它是一个Some(x), and x被返回。也就是说，这个?运算符的行为非常像>>=，除了它不采取闭包，并运行它x if a is Some(x)。相反，它会通过让当前函数直接操作来使当前函数就是该闭包x.

到目前为止，一切都很好。但是 Rust 还有其他具有这种单子模式的预定义类型，这些类型不在您原来的问题中。例如，Result<T, E>。在 Rust 中，你通常想要避免throw, to panic!, to raise，或者你想怎么称呼它就怎么称呼它。这不是异常管理的方式。相反，如果一个函数返回一个类型T可能会抛出错误，类型为E，那么它应该返回Result<T, E>。它（正如您可能想象的那样）简单地定义为枚举，就像Option<T> was:

enum Result<T, E> {
  Ok(T),
  Err(E),
}

并且，就像Option<T>，Rust 提供了一个基本函子来扮演这种类型，即map (ie. my_result.map(|x| ...)）。然而，就像Option，它还提供了大量其他方法来使用Result对象，但有一种特别惯用的方法：?运算符（是的，再次）！就像选项一样，它的作用如下：

• 如果对象具有以下形式Ok(x)，那么它的值为x;
• 否则，它的形式是Err(y)，它将从当前函数返回Err(y).

实际上，?甚至比这更聪明，因为你的函数可能会调用几个返回的函数Result<_, _>，但具有不同的错误类型。例如，如果您尝试读取文件，则可能会收到 IO 错误。然后你尝试解析一些数据，你可能会得到一个解析器错误。然后你做一些算术，你可能会得到算术错误。为了解决这个问题，你的函数应该返回一个足够通用的错误，以便?可能会在您可能得到的错误（IO、解析、算术……）和您返回的错误之间执行转换。