这个答案从一个激励性的例子开始，通过这个例子，得出一个单子的例子，并正式定义了“单子”。

考虑伪代码中的这三个函数：

f(<x, messages>) := <x, messages "called f. ">
g(<x, messages>) := <x, messages "called g. ">
wrap(x)          := <x, "">

f采用<x，messages>形式的有序对，并返回一个有序对。它保持第一项不变，并在第二项后面附加“called f.”。与g相同。

您可以组合这些函数并获得原始值，以及显示函数调用顺序的字符串：

  f(g(wrap(x)))
= f(g(<x, "">))
= f(<x, "called g. ">)
= <x, "called g. called f. ">

您不喜欢f和g负责将自己的日志消息附加到先前的日志信息。（为了论证起见，想象一下，f和g必须对这对中的第二项执行复杂的逻辑，而不是附加字符串。在两个或多个不同的函数中重复这种复杂的逻辑会很痛苦。）

您更喜欢编写更简单的函数：

f(x)    := <x, "called f. ">
g(x)    := <x, "called g. ">
wrap(x) := <x, "">

但看看当你编写它们时会发生什么：

  f(g(wrap(x)))
= f(g(<x, "">))
= f(<<x, "">, "called g. ">)
= <<<x, "">, "called g. ">, "called f. ">

问题是，将一对传递到函数中并不能得到所需的结果。但如果你可以将一对输入到函数中呢：

  feed(f, feed(g, wrap(x)))
= feed(f, feed(g, <x, "">))
= feed(f, <x, "called g. ">)
= <x, "called g. called f. ">

将feed（f，m）读为“feed m into f”。要将一对＜x，messages＞输入函数f，需要将x传递给f，从f中获取＜y，messages〕，并返回＜y，message message＞。

feed(f, <x, messages>) := let <y, message> = f(x)
                          in  <y, messages message>

请注意，当您对函数执行三项操作时会发生什么：

首先：如果包装一个值，然后将结果对送入函数：

  feed(f, wrap(x))
= feed(f, <x, "">)
= let <y, message> = f(x)
  in  <y, "" message>
= let <y, message> = <x, "called f. ">
  in  <y, "" message>
= <x, "" "called f. ">
= <x, "called f. ">
= f(x)

这与将值传递给函数相同。

第二：如果你把一对放进包装里：

  feed(wrap, <x, messages>)
= let <y, message> = wrap(x)
  in  <y, messages message>
= let <y, message> = <x, "">
  in  <y, messages message>
= <x, messages "">
= <x, messages>

这不会改变这对。

第三：如果定义了一个函数，该函数将x和g（x）输入f：

h(x) := feed(f, g(x))

并向其中输入一对：

  feed(h, <x, messages>)
= let <y, message> = h(x)
  in  <y, messages message>
= let <y, message> = feed(f, g(x))
  in  <y, messages message>
= let <y, message> = feed(f, <x, "called g. ">)
  in  <y, messages message>
= let <y, message> = let <z, msg> = f(x)
                     in  <z, "called g. " msg>
  in <y, messages message>
= let <y, message> = let <z, msg> = <x, "called f. ">
                     in  <z, "called g. " msg>
  in <y, messages message>
= let <y, message> = <x, "called g. " "called f. ">
  in <y, messages message>
= <x, messages "called g. " "called f. ">
= feed(f, <x, messages "called g. ">)
= feed(f, feed(g, <x, messages>))

这与将对输入g和将所得对输入f相同。

你有大部分的单子。现在您只需要了解程序中的数据类型。

<x，“称为f”>是什么类型的值？这取决于x是什么类型的值。如果x是t类型的，那么你的对就是“t和字符串对”类型的值了。称之为M型。

M是一个类型构造器：M本身并不表示一个类型，但一旦你用一个类型填空，M _就表示一个。M int是一对int和一个字符串。M字符串是一对字符串和一个字符串。等

恭喜你，你已经创建了monad！

形式上，你的monad是元组＜M，feed，wrap＞。

monad是一个元组＜M，feed，wrap＞，其中：

M是类型构造函数。feed接受一个（函数接受一个t并返回一个M u）和一个M t并返回M u。wrap接受一个v并返回一个M v。

t、 u和v是可以相同也可以不同的任意三种类型。单子满足您为特定单子证明的三个财产：

将包裹的t送入函数与将未包裹的t传入函数相同。形式上：饲料（f，包装（x））=f（x）将M t喂入包装物对M t没有任何影响。形式上：进给（包裹，m）=m将一个M t（称为M）输入一个函数将t传递到g从g得到一个M u（称为n）将n输入f与m进g从g得到n将n输入f形式上：饲料（h，m）=饲料（f，饲料（g，m）），其中h（x）：=饲料（f，g（x））

通常，feed称为bind（在Haskell中为AKA>>=），wrap称为return。

monad是一个容器，但用于数据。一个特殊的容器。

所有容器都可以有开口、把手和喷口，但这些容器都保证有一定的开口、把手或喷口。

为什么？因为这些有保证的开口、把手和喷口对于以特定、常见的方式拾取和连接容器非常有用。

这使您可以选择不同的容器，而不必对它们了解太多。它还允许不同类型的容器轻松连接在一起。

monad是一种具有两个操作的数据类型：>>=（又名bind）和return（又名unit）。return接受一个任意值并用它创建monad的实例。>>=接受monad的一个实例并在其上映射一个函数。（您已经可以看到monad是一种奇怪的数据类型，因为在大多数编程语言中，您无法编写一个接受任意值并从中创建类型的函数。monad使用一种参数多态性。）

在Haskell表示法中，monad接口是

class Monad m where
  return :: a -> m a
  (>>=) :: forall a b . m a -> (a -> m b) -> m b

这些操作应该遵守某些“法则”，但这并不是非常重要的：“法则”只是将操作的合理实现行为化（基本上，>>=和return应该就如何将值转换为monad实例达成一致，并且>>=是关联的）。

Monad不仅仅是关于状态和I/O：它们抽象了一种常见的计算模式，包括处理状态、I/O、异常和非确定性。可能最容易理解的单子是列表和选项类型：

instance Monad [ ] where
    []     >>= k = []
    (x:xs) >>= k = k x ++ (xs >>= k)
    return x     = [x]

instance Monad Maybe where
    Just x  >>= k = k x
    Nothing >>= k = Nothing
    return x      = Just x

其中[]和：是列表构造函数，++是串联运算符，Just和Nothing是Maybe构造函数。这两个monad都在各自的数据类型上封装了常见的有用的计算模式（请注意，两者都与副作用或I/O无关）。

你真的需要写一些非平凡的Haskell代码来理解monad的含义以及它们为什么有用。

一个非常简单的答案是：

Monad是一种抽象，它为封装值、计算新的封装值和展开封装值提供了接口。

它们在实践中的方便之处在于，它们提供了一个统一的接口，用于创建建模状态而非状态的数据类型。

必须理解Monad是一种抽象，即用于处理某种数据结构的抽象接口。然后，该接口用于构建具有一元行为的数据类型。

你可以在Ruby中的Monads中找到一个非常好且实用的介绍，第1部分：简介。

我最喜欢的Monad教程：

http://www.haskell.org/haskellwiki/All_About_Monads

（在谷歌搜索“monad教程”的17万次点击中！）

@斯图：monads的目的是允许您将（通常）顺序语义添加到纯代码中；您甚至可以组合Monad（使用Monad Transformers）并获得更有趣和复杂的组合语义，例如，带有错误处理的解析、共享状态和日志记录。所有这些在纯代码中都是可能的，monad只允许您将其抽象并在模块化库中重用（在编程中总是很好的），并提供方便的语法使其看起来势在必行。

Haskell已经有了运算符重载[1]：它使用类型类的方式与使用Java或C#中的接口的方式非常相似，但Haskell恰好也允许使用非字母数字标记（如+&&和>）作为中缀标识符。如果您的意思是“重载分号”[2]，那么在您看来这只是运算符重载。“重载分号”听起来像是黑魔法，自找麻烦（想象一下有进取心的Perl黑客听到了这个想法），但关键是没有monad就没有分号，因为纯函数代码不需要或不允许显式排序。

这一切听起来比实际情况要复杂得多。sigfpe的文章很酷，但使用了Haskell来解释它，这有点无法打破理解Haskell到grok Monads和理解Monads到grok Haskell的鸡和蛋的问题。

[1] 这是与monad不同的问题，但monad使用Haskell的运算符重载特性。

[2] 这也是一个过度简化，因为链接一元操作的运算符是>>=（发音为“bind”），但有语法糖（“do”）允许您使用大括号和分号和/或缩进和换行。

monad实际上是“类型运算符”的一种形式。它将做三件事。首先，它会将一种类型的值“包装”（或以其他方式转换）为另一种类型（通常称为“一元类型”）。第二，它将使底层类型上的所有操作（或函数）在monadic类型上可用。最后，它将为将自身与另一个monad组合以生成复合monad提供支持。

“可能monad”本质上等同于Visual Basic/C#中的“可为null的类型”。它接受不可为null的类型“T”并将其转换为“可为null＜T＞”，然后定义所有二进制运算符在可为null＞＜T＞上的含义。

副作用也有类似的表现。创建了一个结构，该结构包含函数返回值旁边的副作用描述。当值在函数之间传递时，“提升”操作会复制副作用。

它们被称为“monad”，而不是更容易理解的“类型运算符”的名称，原因如下：

Monad对他们的行为有限制（详见定义）。这些限制，加上涉及三个运算，符合范畴理论中一个叫做monad的结构，这是一个模糊的数学分支。它们是由“纯”函数语言的支持者设计的纯函数语言的支持者，如模糊的数学分支由于数学晦涩难懂，而且monad与特定的编程风格相关，人们倾向于使用monad这个词作为一种秘密握手。正因为如此，没有人费心去投资一个更好的名字。