monad是一种封装值的数据类型，本质上可以对其应用两个操作：

返回x创建封装x的monad类型的值m>>=f（读作“绑定运算符”）将函数f应用于monad m中的值

这就是monad。还有一些技术问题，但基本上这两个操作定义了monad。真正的问题是，“monad做什么？”，这取决于monad-列表是monad，Maybes是monad；IO操作是monad。当我们说这些东西是monad时，这意味着它们具有返回和>>=的monad接口。

monad是一种封装值的数据类型，本质上可以对其应用两个操作：

返回x创建封装x的monad类型的值m>>=f（读作“绑定运算符”）将函数f应用于monad m中的值

这就是monad。还有一些技术问题，但基本上这两个操作定义了monad。真正的问题是，“monad做什么？”，这取决于monad-列表是monad，Maybes是monad；IO操作是monad。当我们说这些东西是monad时，这意味着它们具有返回和>>=的monad接口。

更新：这个问题是一个非常长的博客系列的主题，你可以在Monads上阅读-谢谢你提出的问题！

就OOP程序员所能理解的（没有任何功能编程背景）而言，什么是monad？

monad是一种类型的“放大器”，它遵守某些规则，并提供某些操作。

首先，什么是“类型放大器”？我指的是某种系统，它可以让你选择一种类型，并将其转换为更特殊的类型。例如，在C#中，考虑Nullable＜T＞。这是一种类型的放大器。它允许您接受一个类型，比如int，并为该类型添加一个新的功能，即现在它可以在以前不能为null时为null。

作为第二个例子，考虑IEnumerable＜T＞。这是一种类型的放大器。它允许您获取一个类型，例如字符串，并为该类型添加一个新功能，即您现在可以从任意数量的单个字符串中创建一个字符串序列。

什么是“特定规则”？简言之，对于基础类型上的函数来说，有一种合理的方法来处理放大的类型，从而使它们遵循函数组合的正常规则。例如，如果你有一个关于整数的函数，比如

int M(int x) { return x + N(x * 2); }

则Nullable＜int＞上的相应函数可以使其中的所有运算符和调用“以与之前相同的方式”一起工作。

（这是难以置信的模糊和不精确；你要求的解释没有假设任何关于功能成分的知识。）

什么是“操作”？

有一个“单元”操作（有时被混淆地称为“返回”操作），它从普通类型中获取值并创建等效的一元值。本质上，这提供了一种获取未放大类型值并将其转换为放大类型值的方法。它可以作为OO语言中的构造函数实现。有一个“绑定”操作，它接受一个一元值和一个可以转换该值的函数，并返回一个新的一元值。Bind是定义monad语义的关键操作。它允许我们将未放大类型上的操作转换为放大类型的操作，这符合前面提到的函数组合规则。通常有一种方法可以使未放大的类型从放大的类型中恢复出来。严格来说，这个操作不需要有monad。（虽然如果你想有一个伴侣，这是必要的。我们不会在本文中进一步考虑这些。）

同样，以Nullable＜T＞为例。可以使用构造函数将int转换为Nullable＜int＞。C#编译器为您处理大多数可为空的“提升”，但如果没有，提升转换很简单：，

int M(int x) { whatever }

转化为

Nullable<int> M(Nullable<int> x) 
{ 
    if (x == null) 
        return null; 
    else 
        return new Nullable<int>(whatever);
}

通过Value属性可以将Nullable＜int＞转换回int。

关键是函数转换。请注意，在转换中如何捕获可为null的操作的实际语义（即对null的操作传播null）。我们可以概括这一点。

假设你有一个从int到int的函数，就像我们最初的M一样。你可以很容易地将它转换成一个接受int并返回Nullable＜int＞的函数，因为你可以通过可空构造函数来运行结果。现在假设你有一个更高阶的方法：

static Nullable<T> Bind<T>(Nullable<T> amplified, Func<T, Nullable<T>> func)
{
    if (amplified == null) 
        return null;
    else
        return func(amplified.Value);
}

看看你能用它做什么？任何接受一个int并返回一个int，或者接受一个整型并返回一一个Nullable＜int＞的方法现在都可以应用可空语义。

此外：假设您有两种方法

Nullable<int> X(int q) { ... }
Nullable<int> Y(int r) { ... }

并且您希望编写它们：

Nullable<int> Z(int s) { return X(Y(s)); }

也就是说，Z是X和Y的合成，但不能这样做，因为X取一个int，Y返回一个Nullable＜int＞。但是，由于您有“绑定”操作，因此您可以执行以下操作：

Nullable<int> Z(int s) { return Bind(Y(s), X); }

monad上的绑定操作使放大类型上的函数组合工作。我在上面写的“规则”是，monad保留了正常函数组合的规则；使用同一函数的合成产生原始函数，合成是关联的，等等。

在C#中，“Bind”被称为“SelectMany”。看看它是如何在序列monad上工作的。我们需要做两件事：将一个值转换为一个序列，并在序列上绑定操作。作为奖励，我们还可以“将序列转换回值”。这些操作包括：

static IEnumerable<T> MakeSequence<T>(T item)
{
    yield return item;
}
// Extract a value
static T First<T>(IEnumerable<T> sequence)
{
    // let's just take the first one
    foreach(T item in sequence) return item; 
    throw new Exception("No first item");
}
// "Bind" is called "SelectMany"
static IEnumerable<T> SelectMany<T>(IEnumerable<T> seq, Func<T, IEnumerable<T>> func)
{
    foreach(T item in seq)
        foreach(T result in func(item))
            yield return result;            
}

可为null的monad规则是“将产生可为null值的两个函数组合在一起，检查内部函数是否产生null值；如果产生null值，则产生null值。如果没有，则调用外部函数产生null值”。这就是nullable的理想语义。

序列monad规则是“将两个生成序列的函数组合在一起，将外部函数应用于内部函数生成的每个元素，然后将所有生成的序列连接在一起”。monad的基本语义在Bind/SelectMany方法中被捕获；这是告诉monad真正含义的方法。

我们可以做得更好。假设您有一个int序列，以及一个接受int并生成字符串序列的方法。我们可以推广绑定操作，以允许组合接受和返回不同放大类型的函数，只要其中一个的输入与另一个的输出匹配：

static IEnumerable<U> SelectMany<T,U>(IEnumerable<T> seq, Func<T, IEnumerable<U>> func)
{
    foreach(T item in seq)
        foreach(U result in func(item))
            yield return result;            
}

现在我们可以说“将这一组单独的整数放大成一系列整数。将这一特定的整数转换成一系列字符串，放大成一组字符串。现在将这两个操作放在一起：将这一系列整数放大成所有字符串序列的串联。”单子允许您合成放大。

它解决了什么问题，最常用的地方是什么？

这相当于问“单例模式解决了什么问题？”，但我会尝试一下。

Monad通常用于解决以下问题：

我需要为这种类型创建新的功能，并且仍然在这种类型上组合旧的功能以使用新的功能。我需要在类型上捕获一堆操作，并将这些操作表示为可组合对象，构建越来越大的组合，直到表示出正确的一系列操作，然后我需要开始获得结果我需要用讨厌副作用的语言清晰地表示副作用操作

C#在设计中使用monad。如前所述，可空模式与“可能是monad”非常相似。LINQ完全由monad构建；SelectMany方法是操作组合的语义工作。（Erik Meijer喜欢指出，每个LINQ函数实际上都可以由SelectMany实现；其他一切都只是为了方便。）

为了澄清我所寻求的理解，假设您正在将一个具有monad的FP应用程序转换为OOP应用程序。如何将monad的职责移植到OOP应用程序中？

大多数OOP语言没有足够丰富的类型系统来直接表示monad模式本身；您需要一个支持高于泛型类型的类型的类型系统。所以我不会这么做。相反，我将实现表示每个monad的泛型类型，并实现表示您需要的三个操作的方法：将值转换为放大值，（可能）将放大值转换为值，以及将未放大值上的函数转换为放大的值上的函数。

一个好的开始是我们如何在C#中实现LINQ。研究SelectMany方法；这是理解序列monad如何在C#中工作的关键。这是一个非常简单的方法，但非常强大！

---

建议进一步阅读：

为了对C#中的单子进行更深入、理论上更合理的解释，我强烈推荐我（埃里克·里佩尔）的同事韦斯·戴尔（Wes Dyer）关于这个主题的文章。这篇文章是当他们最终为我“点击”时向我解释单子的原因。蒙得斯的奇迹这是一个很好的例子，说明了为什么您可能需要一个monad（在示例中使用Haskell）。你本可以发明修道院的！（也许你已经有了。）丹·皮波尼有点像，将上一篇文章“翻译”为JavaScript。詹姆斯·科格兰（James Coglan）所读过的monads最佳简介精选部分从Haskell翻译成JavaScript

---

可选/可能是最基本的一元类型

单子是关于功能组成的。如果函数f：可选<A>->可选<B>，g：可选<B>->可选<C>，h：可选<C>->可选＜D>。然后你可以创作它们

optional<A> opt;
h(g(f(opt)));

monad类型的好处是，您可以改为组合f:A->可选<B>、g:B->可选<C>、h:C->可选<D>。他们可以这样做，因为monadic接口提供了绑定运算符

auto optional<A>::bind(A->optional<B>)->optional<B>

并且可以写作文

optional<A> opt
opt.bind(f)
   .bind(g)
   .bind(h)

monads的好处是我们不再需要处理if（！opt）return nullopt的逻辑；在f、g、h中的每一个中，因为该逻辑被移动到绑定运算符中。

ranges/lists/iterables是第二种最基本的monad类型。

范围的一元特征是我们可以变换然后变平，即从一个整数范围内编码的表示开始[36，98]

我们可以转换为[[m'，'a'，'c'，'h'，'i'，'n'，'e'，'']，['l'，''，'r'，'n'，'i'，'n'，'g'，'.']]

然后压平[am'，'a'，'c'，'h'，'i'，'n'，'e'，'l'，''e'

而不是编写此代码

vector<string> lookup_table;
auto stringify(vector<unsigned> rng) -> vector<char>
{
    vector<char> result;
    for(unsigned key : rng)
       for(char ch : lookup_table[key])
           result.push_back(ch);
       result.push_back(' ')
    result.push_back('.')
    return result
}

我们可以写这个

auto f(unsigned key) -> vector<char>
{
    vector<char> result;
    for(ch : lookup_table[key])
        result.push_back(ch);
    return result
}
auto stringify(vector<unsigned> rng) -> vector<char>
{
    return rng.bind(f);
}

monad将for循环（无符号键：rng）向上推到绑定函数中，从而允许理论上更容易推理的代码。毕达哥拉斯三元组可以在范围-v3中使用嵌套绑定生成（而不是我们看到的可选的链式绑定）

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));
      });
    });
  });

我能想到的最简单的解释是，单声道是一种用符号化结果组成函数的方式（也称为克莱斯利合成）。“embelished”函数具有签名a->（b，smth），其中a和b是可能彼此不同但不一定不同的类型（想想Int，Bool），smth是“上下文”或“embelisement”。

这种类型的函数也可以写成a->m b，其中m相当于“embelisation”smth。因此，这些是在上下文中返回值的函数（想想记录其操作的函数，其中smth是日志消息；或者执行输入/输出的函数，其结果取决于IO操作的结果）。

monad是一个接口（“typeclass”），它让实现者告诉它如何组合这样的函数。实现者需要为任何想要实现接口的m类型定义一个组合函数（a->mb）->（b->mc）->（a->mc）（这是Kleisli组合）。

所以，如果我们说我们有一个元组类型（Int，String），它表示Int上的计算结果，（_，String）是“embelisation”-动作的日志-和两个函数increment：：Int->（Int，String）和twoTimes:：Int->（Int、String），我们希望获得一个函数incamentThenDouble:：Int-＞（Int），这是两个函数的组合，也考虑了日志。

在给定的示例中，两个函数的monad实现应用于整数值2增量ThenDouble 2（等于2倍（增量2））将返回（6，“加法1”。中间结果的增量2等于（3，“加1”），2乘以3等于（6，“加3”）

从这个Kleisli合成函数可以导出通常的一元函数。

monad是一个函数数组

（Pst：函数数组只是一个计算）。

实际上，这些函数不是真正的数组（一个单元格数组中的一个函数），而是由另一个函数>>=链接。>>=允许调整函数i的结果以馈送函数i+1，并在它们之间执行计算或者甚至不调用函数i+1。

这里使用的类型是“带上下文的类型”。这是一个带有“标记”的值。被链接的函数必须采用“裸值”并返回标记结果。>>=的职责之一是从上下文中提取裸值。还有一个函数“return”，它接受一个裸值并将其与一个标记一起放置。

Maybe的一个例子。让我们使用它来存储一个简单的整数，以便进行计算。

-- a * b
multiply :: Int -> Int -> Maybe Int
multiply a b = return  (a*b)

-- divideBy 5 100 = 100 / 5
divideBy :: Int -> Int -> Maybe Int
divideBy 0 _ = Nothing -- dividing by 0 gives NOTHING
divideBy denom num = return (quot num denom) -- quotient of num / denom

-- tagged value
val1 = Just 160 

-- array of functions feeded with val1
array1 = val1 >>= divideBy 2  >>= multiply 3 >>= divideBy  4 >>= multiply 3

-- array of funcionts created with the do notation
-- equals array1 but for the feeded val1
array2 :: Int -> Maybe Int
array2 n = do
       v <- divideBy 2  n
       v <- multiply 3 v
       v <- divideBy 4 v
       v <- multiply 3 v
       return v

-- array of functions, 
-- the first >>= performs 160 / 0, returning Nothing
-- the second >>= has to perform Nothing >>= multiply 3 ....
-- and simply returns Nothing without calling multiply 3 ....
array3 = val1 >>= divideBy 0  >>= multiply 3 >>= divideBy  4 >>= multiply 3

main = do
     print array1
     print (array2 160)
     print array3

为了说明monad是带有助手操作的函数数组，请考虑与上述示例等效，仅使用一个实函数数组

type MyMonad = [Int -> Maybe Int] -- my monad as a real array of functions

myArray1 = [divideBy 2, multiply 3, divideBy 4, multiply 3]

-- function for the machinery of executing each function i with the result provided by function i-1
runMyMonad :: Maybe Int -> MyMonad -> Maybe Int
runMyMonad val [] = val
runMyMonad Nothing _ = Nothing
runMyMonad (Just val) (f:fs) = runMyMonad (f val) fs

它的用法如下：

print (runMyMonad (Just 160) myArray1)