在最近简要回顾了Haskell之后，对于monad本质上是什么，有什么简单、简洁、实用的解释？
我发现，我遇到的大多数解释都很难理解，而且缺乏实际细节。
当前回答
你应该首先了解函子是什么。在此之前，先了解高阶函数。
高阶函数只是一个以函数为自变量的函数。
函子是任何类型构造T，其中存在一个高阶函数，称之为map，它将类型为A->b的函数（给定任意两个类型A和b）转换为函数Ta->Tb。该map函数还必须遵守恒等式和复合法则，以便以下表达式对所有p和q返回true（Haskell表示法）：
map id = id
map (p . q) = map p . map q
例如，名为List的类型构造函数是一个函子，如果它配备了一个类型为（a->b）->Lista->Listb的函数，该函数遵守上述定律。唯一实际的实施是显而易见的。生成的Lista->Listb函数在给定列表上迭代，为每个元素调用（a->b）函数，并返回结果列表。
monad本质上只是一个函子T，它有两个额外的方法，类型为T（T A）->T A的join和类型为A->T A的unit（有时称为return、fork或pure）。对于Haskell中的列表：
join :: [[a]] -> [a]
pure :: a -> [a]
为什么有用？因为例如，您可以使用返回列表的函数映射列表。Join获取生成的列表列表并将它们连接起来。列表是monad，因为这是可能的。
您可以编写一个函数，先映射，然后连接。此函数称为bind或flatMap，或（>>=）或（=<<）。这通常是Haskell中给出monad实例的方式。
monad必须满足某些定律，即联接必须是关联的。这意味着，如果您的值x类型为[[a]]]，那么join（join x）应该等于join（map joinx）。纯必须是联接的标识，这样联接（纯x）==x。
其他回答
在了解这些信息时，对我帮助最大的两件事是：
第8章，“函数解析器”，摘自Graham Hutton的《Haskell编程》一书。实际上，这根本没有提到monad，但如果您能够通读第章并真正理解其中的所有内容，特别是如何评估一系列绑定操作，您将了解monad的内部结构。预计这需要多次尝试。
关于修道院的教程。这提供了几个很好的例子来说明它们的用途，我不得不说，我在Appendex中的类比是为我工作的。
http://mikehadlow.blogspot.com/2011/02/monads-in-c-8-video-of-my-ddd9-monad.html
这是你要找的视频。
用C#演示组合和对齐类型的问题，然后用C#正确实现它们。最后，他展示了F#和Haskell中相同的C#代码的外观。
你应该首先了解函子是什么。在此之前，先了解高阶函数。
高阶函数只是一个以函数为自变量的函数。
函子是任何类型构造T，其中存在一个高阶函数，称之为map，它将类型为A->b的函数（给定任意两个类型A和b）转换为函数Ta->Tb。该map函数还必须遵守恒等式和复合法则，以便以下表达式对所有p和q返回true（Haskell表示法）：
map id = id
map (p . q) = map p . map q
例如，名为List的类型构造函数是一个函子，如果它配备了一个类型为（a->b）->Lista->Listb的函数，该函数遵守上述定律。唯一实际的实施是显而易见的。生成的Lista->Listb函数在给定列表上迭代，为每个元素调用（a->b）函数，并返回结果列表。
monad本质上只是一个函子T，它有两个额外的方法，类型为T（T A）->T A的join和类型为A->T A的unit（有时称为return、fork或pure）。对于Haskell中的列表：
join :: [[a]] -> [a]
pure :: a -> [a]
为什么有用？因为例如，您可以使用返回列表的函数映射列表。Join获取生成的列表列表并将它们连接起来。列表是monad，因为这是可能的。
您可以编写一个函数，先映射，然后连接。此函数称为bind或flatMap，或（>>=）或（=<<）。这通常是Haskell中给出monad实例的方式。
monad必须满足某些定律，即联接必须是关联的。这意味着，如果您的值x类型为[[a]]]，那么join（join x）应该等于join（map joinx）。纯必须是联接的标识，这样联接（纯x）==x。
实际上，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是一种函数组合技术，它使用组合函数bind将某些输入场景的处理具体化，以在组合过程中预处理输入。
在正常合成中，函数compose（>>）用于按顺序将合成的函数应用于其前身的结果。重要的是，所组成的函数需要处理其输入的所有场景。
（x->y）>>（y->z）
这种设计可以通过重组输入来改进，以便更容易地询问相关状态。因此，如果y包含有效性的概念，则值可以变成Mb，例如（is_OK，b），而不是简单的y。
例如，当输入仅可能是一个数字时，而不是返回一个可以尽职尽责地包含数字或不包含数字的字符串，您可以将类型重新构造为bool，以指示元组中存在有效数字和数字，例如bool*float。组合函数现在不再需要解析输入字符串来确定数字是否存在，而只需要检查元组的布尔部分。
（Ma->Mb）>>（Mb->Mc）
在这里，合成与合成一起自然发生，因此每个函数必须单独处理其输入的所有场景，尽管现在这样做要容易得多。
然而，如果我们能够将审讯的工作外化，以应对那些处理场景是常规的情况，那又会怎样呢。例如，如果我们的程序在输入不正常时什么都不做，比如is_OK为false时。如果做到了这一点，那么组合函数就不需要自己处理该场景，从而大大简化了代码并实现了另一个级别的重用。
为了实现这种外部化，我们可以使用bind（>>=）函数来执行组合而不是组合。因此，不是简单地将值从一个函数的输出传递到另一个函数输入，而是检查Ma的M部分，并决定是否以及如何将组合函数应用于a。当然，函数绑定将专门为我们的特定M定义，以便能够检查其结构并执行我们想要的任何类型的应用。尽管如此，a可以是任何东西，因为bind仅在确定应用程序需要时将未检查的a传递给组合函数。此外，组合函数本身也不再需要处理输入结构的M部分，从而简化了它们。因此
（a->Mb）>>=（b->Mc）或更简洁地Mb>>=
简言之，一旦输入被设计为充分暴露某些输入场景，monad就外部化了，从而提供了关于处理这些输入场景的标准行为。这种设计是一种外壳和内容模型，其中外壳包含与组合函数的应用程序相关的数据，并由绑定函数查询，并且仅对绑定函数可用。
因此，单子是三件事：
M外壳，用于保存monad相关信息，实现的绑定函数，用于在将组合函数应用于其在外壳中找到的内容值时使用该外壳信息，以及形式为a->Mb的可组合函数，生成包含单元管理数据的结果。
一般来说，函数的输入比其输出更具限制性，其中可能包括错误条件等；因此，Mb结果结构通常非常有用。例如，当除数为0时，除法运算符不返回数字。
此外，monad可以包括将值a包装成monadic类型Ma的包装函数，以及将一般函数a->b包装成monodic函数a->Mb的包装函数。当然，像bind一样，这样的包装函数是M特有的。例如：
let return a = [a]
let lift f a = return (f a)
绑定函数的设计假定了不可变的数据结构和纯函数，其他事情变得复杂，无法保证。因此，有一元定律：
鉴于
M_
return = (a -> Ma)
f = (a -> Mb)
g = (b -> Mc)
然后
Left Identity : (return a) >>= f === f a
Right Identity : Ma >>= return === Ma
Associative : Ma >>= (f >>= g) === Ma >>= ((fun x -> f x) >>= g)
关联性意味着无论何时应用绑定，绑定都会保留求值顺序。也就是说，在上述关联性的定义中，对f和g的括号化绑定的强制早期评估只会导致期望Ma的函数完成绑定。因此，必须先确定Ma的值，然后才能将其值应用于f，进而将结果应用于g。
