正如丹尼尔·斯皮瓦克（Daniel Spiewak）所解释的，修道院不是隐喻，而是从一种共同模式中产生的一种实用的抽象。

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

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

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用于控制流，就像抽象数据类型用于数据一样。

换句话说，许多开发人员对集合、列表、字典（或哈希、或地图）和树的概念很熟悉。在这些数据类型中有许多特殊情况（例如InsertionOrderPreservingIdentityHashMap）。

然而，当面对程序“流”时，许多开发人员还没有接触到比if、switch/case、do、while、goto（grr）和（可能）闭包更多的构造。

因此，monad只是一个控制流构造。替代monad的更好短语是“控制类型”。

因此，monad具有用于控制逻辑、语句或函数的槽——数据结构中的等价物是，某些数据结构允许您添加数据，并删除数据。

例如，“if”monad：

if( clause ) then block

最简单的是有两个槽：一个子句和一个块。if monad通常用于评估子句的结果，如果不是false，则评估块。许多开发人员在学习“如果”时并没有接触到monad，而且编写有效的逻辑并不需要理解monad。

monad可能会变得更复杂，就像数据结构可能变得更复杂一样，但monad有很多大类可能具有相似的语义，但实现和语法不同。

当然，数据结构可以在单子上迭代或遍历，也可以以同样的方式进行评估。

编译器可能支持也可能不支持用户定义的monad。哈斯克尔当然知道。Ioke有一些类似的功能，尽管语言中没有使用monad一词。

但是，你本可以发明蒙纳斯！

sigfpe说：但所有这些都将单子介绍为需要解释的深奥的东西。但我想说的是，它们一点都不深奥。事实上，面对函数式编程中的各种问题，你会不可避免地被引向某些解决方案，所有这些都是单子的例子。事实上，如果你还没有发明，我希望你现在就发明它们。这是注意到所有这些解决方案实际上都是变相的相同解决方案的一小步。读完这篇文章后，你可能会更好地理解单子上的其他文档，因为你会发现你所看到的一切都是你已经发明的。monads试图解决的许多问题都与副作用有关。因此，我们将从它们开始。（请注意，monad让您做的不仅仅是处理副作用，特别是许多类型的容器对象都可以被视为monad。monad的一些介绍发现，很难协调monad的这两种不同用法，并且只关注其中一种。）在命令式编程语言（如C++）中，函数的行为与数学函数完全不同。例如，假设我们有一个C++函数，它接受一个浮点参数并返回一个浮点结果。从表面上看，它可能有点像一个将实数映射到实数的数学函数，但C++函数可以做的不仅仅是返回一个依赖于其参数的数字。它可以读取和写入全局变量的值，也可以将输出写入屏幕并接收用户的输入。然而，在纯函数语言中，函数只能读取在其参数中提供给它的内容，而它对世界产生影响的唯一方式是通过它返回的值。

世界需要的是另一篇monad博客文章，但我认为这对识别野外现存的monad很有用。

单子是分形

上面是一个叫做Sierpinski三角形的分形，这是我唯一记得画的分形。分形是与上述三角形相似的自相似结构，其中部分与整体相似（在这种情况下，正好是母三角形比例的一半）。单子是分形。给定一个一元数据结构，它的值可以组合成数据结构的另一个值。这就是为什么它对编程有用，这也是为什么它在许多情况下都会出现。

http://mikehadlow.blogspot.com/2011/02/monads-in-c-8-video-of-my-ddd9-monad.html

这是你要找的视频。

用C#演示组合和对齐类型的问题，然后用C#正确实现它们。最后，他展示了F#和Haskell中相同的C#代码的外观。