在最近简要回顾了Haskell之后，对于monad本质上是什么，有什么简单、简洁、实用的解释？
我发现，我遇到的大多数解释都很难理解，而且缺乏实际细节。
当前回答
这个答案从一个激励性的例子开始，通过这个例子，得出一个单子的例子，并正式定义了“单子”。
考虑伪代码中的这三个函数：
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是函数组合运算符的一种自定义实现，它考虑了副作用以及不兼容的输入和返回值（用于链接）。
但是，你本可以发明蒙纳斯！
sigfpe说：但所有这些都将单子介绍为需要解释的深奥的东西。但我想说的是，它们一点都不深奥。事实上，面对函数式编程中的各种问题，你会不可避免地被引向某些解决方案，所有这些都是单子的例子。事实上，如果你还没有发明，我希望你现在就发明它们。这是注意到所有这些解决方案实际上都是变相的相同解决方案的一小步。读完这篇文章后，你可能会更好地理解单子上的其他文档，因为你会发现你所看到的一切都是你已经发明的。monads试图解决的许多问题都与副作用有关。因此，我们将从它们开始。（请注意，monad让您做的不仅仅是处理副作用，特别是许多类型的容器对象都可以被视为monad。monad的一些介绍发现，很难协调monad的这两种不同用法，并且只关注其中一种。）在命令式编程语言（如C++）中，函数的行为与数学函数完全不同。例如，假设我们有一个C++函数，它接受一个浮点参数并返回一个浮点结果。从表面上看，它可能有点像一个将实数映射到实数的数学函数，但C++函数可以做的不仅仅是返回一个依赖于其参数的数字。它可以读取和写入全局变量的值，也可以将输出写入屏幕并接收用户的输入。然而，在纯函数语言中，函数只能读取在其参数中提供给它的内容，而它对世界产生影响的唯一方式是通过它返回的值。
遵循您简短、简洁、实用的指示：
理解monad最简单的方法是在上下文中应用/组合函数。假设你有两个计算，它们都可以看作是两个数学函数f和g。
f取一个String并生成另一个String（取前两个字母）g获取一个String并生成另一个String（大写转换）
因此，在任何语言中，“取前两个字母并将其转换为大写”的转换都会写成g（f（“某个字符串”））。因此，在纯完美函数的世界中，合成只是：先做一件事，然后再做另一件事。
但假设我们生活在一个功能可能失败的世界中。例如：输入字符串可能有一个字符长，因此f将失败。所以在这种情况下
f获取一个String并生成一个String或Nothing。g仅在f未失败时生成字符串。否则，将不生成任何内容
所以现在，g（f（“somestring”））需要一些额外的检查：“计算f，如果它失败，那么g应该返回Nothing，否则计算g”
此思想可应用于任何参数化类型，如下所示：
让Context[Sometype]是Context中Sometype的计算。考虑功能
f： ：AnyType->上下文[Sometype]g： ：某些类型->上下文[AnyOtherType]
合成g（f（））应该读作“compute f。在这个上下文中，做一些额外的计算，然后计算g，如果它在上下文中有意义”
我最喜欢的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”）允许您使用大括号和分号和/或缩进和换行。
http://code.google.com/p/monad-tutorial/正是为了解决这个问题而进行的工作。
