在最近简要回顾了Haskell之后，对于monad本质上是什么，有什么简单、简洁、实用的解释？
我发现，我遇到的大多数解释都很难理解，而且缺乏实际细节。
当前回答
实际上，monad基本上允许回调嵌套（具有相互递归的线程状态（请忽略连字符））（以可组合（或可分解）的方式）（具有类型安全性（有时（取决于语言）））)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
例如，这不是单子：
//JavaScript is 'Practical'
var getAllThree =
bind(getFirst, function(first){
return bind(getSecond,function(second){
return bind(getThird, function(third){
var fancyResult = // And now make do fancy
// with first, second,
// and third
return RETURN(fancyResult);
});});});
但是monad启用了这样的代码。monad实际上是一组类型：{bind，RETURN，也许其他我不认识的人…}。这本质上是无关紧要的，实际上是不切实际的。
所以现在我可以使用它：
var fancyResultReferenceOutsideOfMonad =
getAllThree(someKindOfInputAcceptableToOurGetFunctionsButProbablyAString);
//Ignore this please, throwing away types, yay JavaScript:
// RETURN = K
// bind = \getterFn,cb ->
// \in -> let(result,newState) = getterFn(in) in cb(result)(newState)
或将其分解：
var getFirstTwo =
bind(getFirst, function(first){
return bind(getSecond,function(second){
var fancyResult2 = // And now make do fancy
// with first and second
return RETURN(fancyResult2);
});})
, getAllThree =
bind(getFirstTwo, function(fancyResult2){
return bind(getThird, function(third){
var fancyResult3 = // And now make do fancy
// with fancyResult2,
// and third
return RETURN(fancyResult3);
});});
或者忽略某些结果：
var getFirstTwo =
bind(getFirst, function(first){
return bind(getSecond,function(second){
var fancyResult2 = // And now make do fancy
// with first and second
return RETURN(fancyResult2);
});})
, getAllThree =
bind(getFirstTwo, function(____dontCare____NotGonnaUse____){
return bind(getThird, function(three){
var fancyResult3 = // And now make do fancy
// with `three` only!
return RETURN(fancyResult3);
});});
或者从以下内容简化一个小案例：
var getFirstTwo =
bind(getFirst, function(first){
return bind(getSecond,function(second){
var fancyResult2 = // And now make do fancy
// with first and second
return RETURN(fancyResult2);
});})
, getAllThree =
bind(getFirstTwo, function(_){
return bind(getThird, function(three){
return RETURN(three);
});});
收件人（使用“正确身份”）：
var getFirstTwo =
bind(getFirst, function(first){
return bind(getSecond,function(second){
var fancyResult2 = // And now make do fancy
// with first and second
return RETURN(fancyResult2);
});})
, getAllThree =
bind(getFirstTwo, function(_){
return getThird;
});
或者把它们挤在一起：
var getAllThree =
bind(getFirst, function(first_dontCareNow){
return bind(getSecond,function(second_dontCareNow){
return getThird;
});});
这些能力的实用性并没有真正显现出来，或者变得清晰，直到你试图解决真正的棘手问题例如解析或模块/ajax/资源加载。
你能想象成千上万行indexOf/subString逻辑吗？如果频繁的解析步骤包含在小函数中呢？像字符、空格、大写字符或数字这样的函数？如果这些函数在回调中给出了结果，而不必与Regex集团和争论发生冲突？如果它们的组成/分解被很好地理解了呢？这样你就可以从下往上构建大型解析器了吗？
因此，管理嵌套回调范围的能力非常实用，尤其是在使用monadic解析器组合器库时。（也就是说，根据我的经验）
不要挂断电话：-分类理论-可能是月-莫纳德定律-哈斯克尔- !!!!
其他回答
（另请参见“什么是monad？”中的答案）
蒙纳斯的一个很好的动机是西格菲（丹·皮波尼）的《你本可以发明蒙纳斯！（也许你已经有了）。还有很多其他monad教程，其中许多都试图使用各种类比以“简单的术语”来解释monad：这就是monad教程谬论；避开它们。
正如MacIver博士在《告诉我们为什么你的语言很糟糕》中所说：所以，我讨厌Haskell的事情：让我们从显而易见的开始。Monad教程。不，不是单子。特别是教程。他们没完没了，夸夸其谈，亲爱的上帝，他们太乏味了。此外，我从未见过任何令人信服的证据表明它们确实有帮助。阅读类定义，编写一些代码，忘掉这个可怕的名字。
你说你懂“也许莫纳德”吗？很好，你在路上了。只要开始使用其他monad，迟早你会了解monad的一般含义。
（如果你以数学为导向，你可能想忽略几十个教程，学习定义，或遵循类别理论的讲座：）定义的主要部分是Monad M包含一个“类型构造器”，为每个现有类型“T”定义一个新类型“M T”，以及在“常规”类型和“M”类型之间来回移动的一些方式。]
同样，令人惊讶的是，对monad最好的介绍之一实际上是介绍monad的早期学术论文之一，Philip Wadler的Monad for functional programming。它实际上有一些实用的、非平凡的激励性例子，与许多人工教程不同。
经过努力，我想我终于明白了单子。在重新阅读了我自己对绝大多数投票结果的冗长批评之后，我将给出这个解释。
要理解单子，需要回答三个问题：
你为什么需要蒙纳德？什么是单子？如何实现monad？
正如我在最初的评论中所指出的，有太多的monad解释被第3个问题所困扰，没有，也没有充分地涵盖第2个问题或第1个问题。
你为什么需要蒙纳德？
Haskell等纯函数式语言与C或Java等命令式语言的不同之处在于，纯函数式程序不一定按特定顺序执行，一步一步执行。Haskell程序更类似于一个数学函数，在该函数中，您可以以任意数量的潜在阶数求解“方程”。这带来了许多好处，其中之一是它消除了某些类型的错误的可能性，特别是那些与“状态”相关的错误。
然而，使用这种编程风格，有些问题不是很容易解决的。有些事情，比如控制台编程和文件i/o，需要按照特定的顺序进行，或者需要维护状态。处理这个问题的一种方法是创建一种表示计算状态的对象，以及一系列将状态对象作为输入并返回新修改的状态对象的函数。
因此，让我们创建一个假设的“状态”值，它表示控制台屏幕的状态。这个值是如何构造的并不重要，但假设它是一个字节长度的ascii字符数组，表示屏幕上当前可见的内容，以及一个表示用户输入的最后一行伪代码的数组。我们已经定义了一些接受控制台状态、修改它并返回新控制台状态的函数。
consolestate MyConsole = new consolestate;
因此，要进行控制台编程，但以纯函数的方式，您需要在彼此之间嵌套许多函数调用。
consolestate FinalConsole = print(input(print(myconsole, "Hello, what's your name?")),"hello, %inputbuffer%!");
以这种方式编程保持了“纯”的功能风格，同时强制对控制台的更改按特定顺序进行。但是，我们可能希望像上面的示例一样，一次只执行几个操作。以这种方式嵌套函数将开始变得笨拙。我们想要的是基本上与上面相同的代码，但编写得更像这样：
consolestate FinalConsole = myconsole:
print("Hello, what's your name?"):
input():
print("hello, %inputbuffer%!");
这确实是一种更方便的写法。但我们如何做到这一点呢？
什么是单子？
一旦你定义了一个类型（比如consoleestate），以及一系列专门为该类型操作而设计的函数，你就可以通过定义一个操作符（比如：（bind））将这些东西的整个包变成一个“monad”，该操作符会自动将返回值输入到左边的函数参数中，转换为与特定类型的绑定运算符一起工作的函数。
如何实现monad？
看到其他答案，似乎可以很自由地跳到细节中。
解释“什么是monad”有点像说“什么是数字？”我们总是使用数字。但想象一下，你遇到了一个对数字一无所知的人。你怎么解释数字是什么？你怎么开始描述为什么这可能有用？
什么是单子？简单的回答是：这是一种将操作链接在一起的特定方式。
本质上，您正在编写执行步骤，并将它们与“绑定函数”链接在一起。（在Haskell中，它名为>>=。）您可以自己编写对绑定运算符的调用，也可以使用语法糖，使编译器为您插入这些函数调用。但无论哪种方式，每个步骤都由对该绑定函数的调用分隔。
因此绑定函数就像分号；它将流程中的步骤分开。bind函数的任务是获取上一步的输出，并将其输入下一步。
听起来不太难，对吧？但单子不止一种。为什么？怎样
好吧，bind函数可以从一个步骤中获取结果，并将其传递给下一个步骤。但如果这就是单子的全部。。。这实际上不是很有用。理解这一点很重要：每个有用的monad除了做monad之外，还做其他事情。每一个有用的单子都有一种“特殊的力量”，这使它独一无二。
（没有什么特别作用的monad被称为“身份monad”。与身份函数类似，这听起来是一件毫无意义的事情，但事实证明并非如此……但这是另一回事™.)
基本上，每个monad都有自己的绑定函数实现。你可以编写一个绑定函数，这样它就可以在执行步骤之间做一些傻事。例如：
如果每个步骤都返回一个成功/失败指示符，则只有在前一个步骤成功的情况下，才能让绑定执行下一个步骤。这样，失败的步骤“自动”中止整个序列，而无需您进行任何条件测试。（故障单）扩展这个想法，您可以实现“异常”。（错误单点或异常单点。）因为您自己定义它们，而不是将其作为一种语言特性，所以您可以定义它们的工作方式。（例如，您可能希望忽略前两个异常，仅在引发第三个异常时中止。）您可以使每个步骤返回多个结果，并让bind函数对其进行循环，将每个结果输入到下一步。这样，在处理多个结果时，就不必一直到处写循环。绑定函数“自动”为您完成所有这些。（单子）除了将“结果”从一个步骤传递到另一个步骤之外，还可以让bind函数传递额外的数据。这些数据现在不会显示在源代码中，但您仍然可以从任何地方访问它，而无需手动将其传递给每个函数。（《读者》杂志）您可以这样做，以便可以替换“额外数据”。这允许您模拟破坏性更新，而无需实际执行破坏性更新。（莫纳德州及其堂弟作家莫纳德。）因为您只是在模拟破坏性更新，所以您可以轻松地完成真正的破坏性更新所无法完成的事情。例如，您可以撤消上一次更新，或恢复到旧版本。你可以制作一个可以暂停计算的monad，这样你就可以暂停你的程序，进入并修补内部状态数据，然后恢复它。您可以将“continuations”实现为monad。这可以让你打破人们的想法！
所有这些和更多的都可以通过monad实现。当然，这一切在没有单子的情况下也是完全可能的。使用monad非常简单。
遵循您简短、简洁、实用的指示：
理解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基本上允许回调嵌套（具有相互递归的线程状态（请忽略连字符））（以可组合（或可分解）的方式）（具有类型安全性（有时（取决于语言）））)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
例如，这不是单子：
//JavaScript is 'Practical'
var getAllThree =
bind(getFirst, function(first){
return bind(getSecond,function(second){
return bind(getThird, function(third){
var fancyResult = // And now make do fancy
// with first, second,
// and third
return RETURN(fancyResult);
});});});
但是monad启用了这样的代码。monad实际上是一组类型：{bind，RETURN，也许其他我不认识的人…}。这本质上是无关紧要的，实际上是不切实际的。
所以现在我可以使用它：
var fancyResultReferenceOutsideOfMonad =
getAllThree(someKindOfInputAcceptableToOurGetFunctionsButProbablyAString);
//Ignore this please, throwing away types, yay JavaScript:
// RETURN = K
// bind = \getterFn,cb ->
// \in -> let(result,newState) = getterFn(in) in cb(result)(newState)
或将其分解：
var getFirstTwo =
bind(getFirst, function(first){
return bind(getSecond,function(second){
var fancyResult2 = // And now make do fancy
// with first and second
return RETURN(fancyResult2);
});})
, getAllThree =
bind(getFirstTwo, function(fancyResult2){
return bind(getThird, function(third){
var fancyResult3 = // And now make do fancy
// with fancyResult2,
// and third
return RETURN(fancyResult3);
});});
或者忽略某些结果：
var getFirstTwo =
bind(getFirst, function(first){
return bind(getSecond,function(second){
var fancyResult2 = // And now make do fancy
// with first and second
return RETURN(fancyResult2);
});})
, getAllThree =
bind(getFirstTwo, function(____dontCare____NotGonnaUse____){
return bind(getThird, function(three){
var fancyResult3 = // And now make do fancy
// with `three` only!
return RETURN(fancyResult3);
});});
或者从以下内容简化一个小案例：
var getFirstTwo =
bind(getFirst, function(first){
return bind(getSecond,function(second){
var fancyResult2 = // And now make do fancy
// with first and second
return RETURN(fancyResult2);
});})
, getAllThree =
bind(getFirstTwo, function(_){
return bind(getThird, function(three){
return RETURN(three);
});});
收件人（使用“正确身份”）：
var getFirstTwo =
bind(getFirst, function(first){
return bind(getSecond,function(second){
var fancyResult2 = // And now make do fancy
// with first and second
return RETURN(fancyResult2);
});})
, getAllThree =
bind(getFirstTwo, function(_){
return getThird;
});
或者把它们挤在一起：
var getAllThree =
bind(getFirst, function(first_dontCareNow){
return bind(getSecond,function(second_dontCareNow){
return getThird;
});});
这些能力的实用性并没有真正显现出来，或者变得清晰，直到你试图解决真正的棘手问题例如解析或模块/ajax/资源加载。
你能想象成千上万行indexOf/subString逻辑吗？如果频繁的解析步骤包含在小函数中呢？像字符、空格、大写字符或数字这样的函数？如果这些函数在回调中给出了结果，而不必与Regex集团和争论发生冲突？如果它们的组成/分解被很好地理解了呢？这样你就可以从下往上构建大型解析器了吗？
因此，管理嵌套回调范围的能力非常实用，尤其是在使用monadic解析器组合器库时。（也就是说，根据我的经验）
不要挂断电话：-分类理论-可能是月-莫纳德定律-哈斯克尔- !!!!
