在最近简要回顾了Haskell之后，对于monad本质上是什么，有什么简单、简洁、实用的解释？
我发现，我遇到的大多数解释都很难理解，而且缺乏实际细节。
当前回答
公主对F#计算表达式的解释帮助了我，尽管我仍然不能说我真的理解了。
编辑：这个系列-用javascript解释monad-对我来说是一个“打破平衡”的系列。
http://blog.jcoglan.com/2011/03/05/translation-from-haskell-to-javascript-of-selected-portions-of-the-best-introduction-to-monads-ive-ever-read/http://blog.jcoglan.com/2011/03/06/monad-syntax-for-javascript/http://blog.jcoglan.com/2011/03/11/promises-are-the-monad-of-asynchronous-programming/
我认为理解单子是一件让你毛骨悚然的事。从这个意义上说，尽可能多地阅读“教程”是一个好主意，但通常奇怪的东西（不熟悉的语言或语法）会让你的大脑无法专注于基本内容。
有些事情我很难理解：
基于规则的解释对我来说从未奏效，因为大多数实际示例实际上需要的不仅仅是返回/绑定。此外，称之为规则也无济于事。这更像是“有些东西有共同点，我们把它们称为‘单子’，把共同点称为‘规则’”。Return（a->M<a>）和Bind（M<a>->（a->M<b>）->M<b>）很好，但我永远无法理解Bind如何从M<a>中提取a，以便将其传递给a->M<b>。我不认为我在任何地方读过（也许这对其他人来说都很明显），Return（M<a>->a）的反面必须存在于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。
第一：如果你不是数学家，monad这个词有点空洞。另一个术语是计算构建器，它更能描述它们的实际用途。
它们是链接操作的模式。它看起来有点像面向对象语言中的方法链接，但机制略有不同。
该模式主要用于函数式语言（特别是Haskell，它普遍使用monad），但也可以用于支持高阶函数的任何语言（即可以将其他函数作为参数的函数）。
JavaScript中的数组支持该模式，因此让我们将其作为第一个示例。
模式的要点是我们有一个类型（在本例中为Array），它有一个以函数作为参数的方法。提供的操作必须返回相同类型的实例（即返回数组）。
首先是一个不使用monad模式的方法链接示例：
[1,2,3].map(x => x + 1)
结果是[2,3,4]。代码不符合monad模式，因为我们作为参数提供的函数返回的是数字，而不是数组。monad形式的相同逻辑是：
[1,2,3].flatMap(x => [x + 1])
这里我们提供了一个返回Array的操作，所以现在它符合模式。flatMap方法为数组中的每个元素执行提供的函数。它期望每个调用都有一个数组作为结果（而不是单个值），但将得到的数组集合并为一个数组。所以最终的结果是相同的，数组[2,3,4]。
（提供给map或flatMap等方法的函数参数在JavaScript中通常称为“回调”。我将其称为“操作”，因为它更通用。）
如果我们连锁多个操作（以传统方式）：
[1,2,3].map(a => a + 1).filter(b => b != 3)
数组中的结果[2,4]
monad形式的相同链接：
[1,2,3].flatMap(a => [a + 1]).flatMap(b => b != 3 ? [b] : [])
产生相同的结果，即数组[2,4]。
您将立即注意到monad格式比非monad格式更难看！这正好表明单子不一定“好”。它们是一种有时有益有时不有益的模式。
请注意，monad模式可以以不同的方式组合：
[1,2,3].flatMap(a => [a + 1].flatMap(b => b != 3 ? [b] : []))
这里的绑定是嵌套的，而不是链式的，但结果是一样的。这是单子的一个重要属性，我们稍后会看到。这意味着组合的两个操作可以被视为单个操作。
该操作允许返回具有不同元素类型的数组，例如，将数字数组转换为字符串数组或其他东西；只要它仍然是一个数组。
这可以使用Typescript表示法更正式地描述。数组的类型为array＜T＞，其中T是数组中元素的类型。flatMap（）方法接受类型为T=>Array<U>的函数参数，并返回一个Array<U>。
一般来说，monad是任何类型的Foo＜Bar＞，它有一个“bind”方法，该方法接受类型为Bar＝＞Foo＜Baz＞的函数参数，并返回一个Foo＜Baz＞。
这回答了单子是什么。这个答案的其余部分将试图通过示例来解释为什么monads在Haskell这样的语言中是一种有用的模式，而Haskell对monads有很好的支持。
Haskell和Do表示法
要将map/filter示例直接转换为Haskell，我们将flatMap替换为>>=运算符：
[1,2,3] >>= \a -> [a+1] >>= \b -> if b == 3 then [] else [b]
>>=运算符是Haskell中的绑定函数。当操作数是一个列表时，它与JavaScript中的flatMap相同，但对于其他类型，它被重载了不同的含义。
但是Haskell还为monad表达式提供了专用语法do块，它完全隐藏了绑定运算符：
do a <- [1,2,3]
b <- [a+1]
if b == 3 then [] else [b]
这将隐藏“管道”，并让您专注于在每个步骤中应用的实际操作。
在do块中，每一行都是一个操作。约束仍然认为块中的所有操作都必须返回相同的类型。因为第一个表达式是一个列表，所以其他操作也必须返回一个列表。
向后箭头<-看起来像赋值，但请注意，这是绑定中传递的参数。因此，当右侧的表达式是整数列表时，左侧的变量将是一个整数，但将对列表中的每个整数执行。
示例：安全导航（Maybe类型）
关于列表，让我们来看看monad模式如何对其他类型有用。
某些函数可能不总是返回有效值。在Haskell中，这由Maybe类型表示，该类型是Just value或Nothing选项。
总是返回有效值的链接操作当然很简单：
streetName = getStreetName (getAddress (getUser 17))
但如果任何函数都可以返回Nothing呢？我们需要单独检查每个结果，如果不是Nothing，则只将值传递给下一个函数：
case getUser 17 of
Nothing -> Nothing
Just user ->
case getAddress user of
Nothing -> Nothing
Just address ->
getStreetName address
很多重复检查！想象一下如果链条更长。Haskell用Maybe的monad模式解决了这个问题：
do
user <- getUser 17
addr <- getAddress user
getStreetName addr
这个do块调用Maybe类型的绑定函数（因为第一个表达式的结果是Maybe）。绑定函数仅在值为Just值时执行以下操作，否则只传递Nothing。
这里使用monad模式来避免重复代码。这与其他一些语言使用宏来简化语法的方式类似，尽管宏以非常不同的方式实现了相同的目标。
请注意，Haskell中monad模式和monad友好语法的结合导致了代码更干净。在JavaScript这样的语言中，如果没有对monad的任何特殊语法支持，我怀疑monad模式是否能够在这种情况下简化代码。
可变状态
Haskell不支持可变状态。所有变量都是常量，所有值都是不可变的。但State类型可用于模拟具有可变状态的编程：
add2 :: State Integer Integer
add2 = do
-- add 1 to state
x <- get
put (x + 1)
-- increment in another way
modify (+1)
-- return state
get
evalState add2 7
=> 9
add2函数构建一个monad链，然后以7作为初始状态对其求值。
显然，这在Haskell中才有意义。其他语言支持开箱即用的可变状态。Haskell通常在语言特性上是“选择加入”的——您可以在需要时启用可变状态，并且类型系统确保效果是显式的。IO是这方面的另一个例子。
IO
IO类型用于链接和执行“不纯”函数。
与任何其他实用语言一样，Haskell有一系列与外界接口的内置函数：putStrLine、readLine等。这些函数被称为“不纯”，因为它们要么会产生副作用，要么会产生不确定性的结果。即使是像获取时间这样简单的事情也被认为是不纯洁的，因为结果是不确定的——用相同的参数调用两次可能会返回不同的值。
纯函数是确定性的——它的结果完全取决于传递的参数，除了返回值之外，它对环境没有任何副作用。
Haskell大力鼓励使用纯函数——这是该语言的一个主要卖点。不幸的是，对于纯粹主义者来说，你需要一些不纯的函数来做任何有用的事情。Haskell折衷方案是将纯函数和不纯函数彻底分开，并保证纯函数无法直接或间接执行不纯函数。
这是通过给所有不纯函数赋予IO类型来保证的。Haskell程序的入口点是具有IO类型的主函数，因此我们可以在顶层执行不纯的函数。
但是该语言如何防止纯函数执行不纯函数？这是因为Haskell的懒惰本性。只有当某个函数的输出被其他函数消耗时，才执行该函数。但除了将IO值分配给main之外，没有办法使用它。因此，如果一个函数想要执行一个不纯的函数，它必须连接到main并具有IO类型。
对IO操作使用monad链接还可以确保它们以线性和可预测的顺序执行，就像命令式语言中的语句一样。
这让我们看到大多数人会用Haskell编写的第一个程序：
main :: IO ()
main = do
putStrLn ”Hello World”
当只有一个操作，因此没有什么要绑定时，do关键字是多余的，但为了保持一致性，我还是保留了它。
（）类型表示“无效”。这种特殊的返回类型仅适用于因其副作用而调用的IO函数。
更长的示例：
main = do
putStrLn "What is your name?"
name <- getLine
putStrLn "hello" ++ name
这构建了一个IO操作链，因为它们被分配给主功能，所以它们被执行。
将IO与Maybe进行比较表明了monad模式的多功能性。对于Maybe，该模式用于通过将条件逻辑移动到绑定函数来避免重复代码。对于IO，该模式用于确保IO类型的所有操作都是有序的，并且IO操作不会“泄漏”到纯函数。
总结
在我的主观看法中，monad模式只有在对该模式有一些内置支持的语言中才真正有价值。否则，它只会导致过于复杂的代码。但是Haskell（和其他一些语言）有一些内置支持，隐藏了繁琐的部分，然后该模式可以用于各种有用的事情。喜欢：
避免重复代码（可能）为程序的分隔区域添加可变状态或异常等语言特性。将讨厌的东西与美好的东西隔离开来（IO）嵌入式域特定语言（解析器）将GOTO添加到语言中。
世界需要的是另一篇monad博客文章，但我认为这对识别野外现存的monad很有用。
单子是分形
上面是一个叫做Sierpinski三角形的分形，这是我唯一记得画的分形。分形是与上述三角形相似的自相似结构，其中部分与整体相似（在这种情况下，正好是母三角形比例的一半）。单子是分形。给定一个一元数据结构，它的值可以组合成数据结构的另一个值。这就是为什么它对编程有用，这也是为什么它在许多情况下都会出现。
monad是用于封装状态变化的对象的东西。在不允许您具有可修改状态的语言（例如，Haskell）中最常遇到这种情况。
例如文件I/O。
您将能够使用文件I/O的monad来将不断变化的状态本质与使用monad的代码隔离开来。Monad内部的代码可以有效地忽略Monad外部世界的变化状态，这使您更容易理解程序的整体效果。
我将尝试在Haskell的背景下解释Monad。
在函数式编程中，函数组合很重要。它允许我们的程序由小的、易于阅读的函数组成。
假设我们有两个函数：g:：Int->String和f:：String->Bool。
我们可以做（f.g）x，这与f（gx）相同，其中x是Int值。
当进行合成/将一个函数的结果应用到另一个函数时，使类型匹配是很重要的。在上述情况下，g返回的结果类型必须与f接受的类型相同。
但有时值是在上下文中的，这使得排列类型有点不容易。（在上下文中设置值非常有用。例如，Maybe Int类型表示可能不存在的Int值，IO String类型表示由于执行某些副作用而存在的String值。）
假设我们现在有g1：：Int->Maybe String和f1：：String->Maybe Bool。g1和f1分别与g和f非常相似。
我们不能做（f1.g1）x或f1（g1 x），其中x是Int值。g1返回的结果类型不是f1期望的类型。
我们可以用。运算符，但现在我们不能用..组合f1和g1。。问题是我们不能直接将上下文中的值传递给期望值不在上下文中的函数。
如果我们引入一个运算符来组合g1和f1，这样我们就可以写出（f1 operator g1）x，这不是很好吗？g1返回上下文中的值。该值将脱离上下文并应用于f1。是的，我们有这样一个操作员。它是<=<。
我们还有一个>>=运算符，它为我们做了完全相同的事情，尽管语法略有不同。
我们写：g1 x>>=f1。g1 x是Maybe Int值。>>=运算符帮助将Int值从“可能不存在”上下文中取出，并将其应用于f1。f1的结果是Maybe Bool，它将是整个>>=操作的结果。
最后，为什么Monad有用？因为Monad是定义>>=运算符的类型类，与定义==和/=运算符的Eq类型类非常相似。
总之，Monad类型类定义了>>=运算符，该运算符允许我们将上下文中的值（我们称为这些monadic值）传递给不需要上下文中值的函数。将考虑上下文。
如果这里需要记住一点，那就是Monads允许在上下文中包含值的函数组合。
