在最近简要回顾了Haskell之后，对于monad本质上是什么，有什么简单、简洁、实用的解释？
我发现，我遇到的大多数解释都很难理解，而且缺乏实际细节。
当前回答
我最喜欢的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”）允许您使用大括号和分号和/或缩进和换行。
其他回答
monad实际上是“类型运算符”的一种形式。它将做三件事。首先，它会将一种类型的值“包装”（或以其他方式转换）为另一种类型（通常称为“一元类型”）。第二，它将使底层类型上的所有操作（或函数）在monadic类型上可用。最后，它将为将自身与另一个monad组合以生成复合monad提供支持。
“可能monad”本质上等同于Visual Basic/C#中的“可为null的类型”。它接受不可为null的类型“T”并将其转换为“可为null＜T＞”，然后定义所有二进制运算符在可为null＞＜T＞上的含义。
副作用也有类似的表现。创建了一个结构，该结构包含函数返回值旁边的副作用描述。当值在函数之间传递时，“提升”操作会复制副作用。
它们被称为“monad”，而不是更容易理解的“类型运算符”的名称，原因如下：
Monad对他们的行为有限制（详见定义）。这些限制，加上涉及三个运算，符合范畴理论中一个叫做monad的结构，这是一个模糊的数学分支。它们是由“纯”函数语言的支持者设计的纯函数语言的支持者，如模糊的数学分支由于数学晦涩难懂，而且monad与特定的编程风格相关，人们倾向于使用monad这个词作为一种秘密握手。正因为如此，没有人费心去投资一个更好的名字。
Monad是一种带有特殊机器的盒子，它允许你从两个嵌套的盒子中制作一个普通的盒子，但仍然保持两个盒子的一些形状。
具体来说，它允许您执行连接，类型为Monad m=>m（m a）->m a。
它还需要一个返回操作，它只包装一个值。return：：Monad m=>a->m a你也可以说joinunboxes和return wrappes，但join不是Monad m=>m a->a类型的（它不会打开所有Monad，而是打开Monad，Monad在其中）
所以它取一个Monad盒子（Monad m=>，m），里面有一个盒子（（m a）），然后生成一个普通盒子（m a。
然而，Monad通常用于（>>=）（口语“bind”）运算符，它本质上只是一个fmap和一个接一个的join。具体而言，
x >>= f = join (fmap f x)
(>>=) :: Monad m => (a -> m b) -> m a -> m b
请注意，函数出现在第二个参数中，而不是fmap。
此外，join=（>>=id）。
为什么这有用？本质上，它允许您在某种框架（Monad）中工作时制作将动作串在一起的程序。
Haskell中Monad的最突出用途是IO Monad。现在，IO是对Haskell中的Action进行分类的类型。在这里，Monad系统是唯一的保存方式（华丽的词）：
参考透明度懒惰纯洁
本质上，像getLine:：IOString这样的IO操作不能被String替换，因为它总是具有不同的类型。把IO想象成一种神奇的盒子，可以把东西传送给你。然而，仍然只是说getLine:：IOString和所有函数都接受IOa会导致混乱，因为可能不需要这些函数。const“üp§”getLine会做什么？（const丢弃第二个参数。const a b=a。）getLine不需要求值，但应该执行IO！这使得行为相当不可预测，也使得类型系统不那么“纯粹”，因为所有函数都将采用a和IOa值。
输入IO Monad。
要将动作串在一起，只需展平嵌套的动作。要将函数应用于IO操作的输出，IO a类型中的a，只需使用（>>=）。
例如，输出输入的行（输出行是一个生成IO操作的函数，匹配右参数>>=）：
getLine >>= putStrLn :: IO ()
-- putStrLn :: String -> IO ()
这可以用do环境更直观地写出来：
do line <- getLine
putStrLn line
本质上，这样的do块：
do x <- a
y <- b
z <- f x y
w <- g z
h x
k <- h z
l k w
…转化为：
a >>= \x ->
b >>= \y ->
f x y >>= \z ->
g z >>= \w ->
h x >>= \_ ->
h z >>= \k ->
l k w
还有m>>=\_->f的>>运算符（当框中的值不需要在框中创建新框时）也可以写成a>>b=a>>=constb（consta b=a）
此外，返回运算符是根据IO直觉建模的-它返回一个具有最小上下文的值，在这种情况下没有IO。由于IO a中的a表示返回的类型，这类似于命令式编程语言中的return（a），但它不会停止操作链！f>>=return>>=g与f>>=g相同。仅当您返回的术语在链中较早创建时才有用-请参见上文。
当然，还有其他Monad，否则它不会被称为Monad，它会被称为“IO控制”之类的东西。
例如，List Monad（Monad[]）通过串联变平-使（>>=）运算符对列表的所有元素执行函数。这可以被视为“不确定性”，其中列表是许多可能的值，而Monad框架正在进行所有可能的组合。
例如（GHCi）：
Prelude> [1, 2, 3] >>= replicate 3 -- Simple binding
[1, 1, 1, 2, 2, 2, 3, 3, 3]
Prelude> concat (map (replicate 3) [1, 2, 3]) -- Same operation, more explicit
[1, 1, 1, 2, 2, 2, 3, 3, 3]
Prelude> [1, 2, 3] >> "uq"
"uququq"
Prelude> return 2 :: [Int]
[2]
Prelude> join [[1, 2], [3, 4]]
[1, 2, 3, 4]
因为：
join a = concat a
a >>= f = join (fmap f a)
return a = [a] -- or "= (:[])"
如果出现这种情况，“也许莫纳德”只会将所有结果作废为“无”。也就是说，绑定自动检查函数（a>>=f）是否返回或值（a>>>=f）是否为Nothing，然后也返回Nothing。
join Nothing = Nothing
join (Just Nothing) = Nothing
join (Just x) = x
a >>= f = join (fmap f a)
或者更明确地说：
Nothing >>= _ = Nothing
(Just x) >>= f = f x
State Monad用于同时修改某些共享状态-s->（a，s）的函数，因此>>=的参数为：a->s->（a，s）。这个名称有点用词不当，因为State实际上是用于状态修改功能，而不是用于状态——状态本身确实没有有趣的财产，它只是被改变了。
例如：
pop :: [a] -> (a , [a])
pop (h:t) = (h, t)
sPop = state pop -- The module for State exports no State constructor,
-- only a state function
push :: a -> [a] -> ((), [a])
push x l = ((), x : l)
sPush = state push
swap = do a <- sPop
b <- sPop
sPush a
sPush b
get2 = do a <- sPop
b <- sPop
return (a, b)
getswapped = do swap
get2
那么：
Main*> runState swap [1, 2, 3]
((), [2, 1, 3])
Main*> runState get2 [1, 2, 3]
((1, 2), [1, 2, 3]
Main*> runState (swap >> get2) [1, 2, 3]
((2, 1), [2, 1, 3])
Main*> runState getswapped [1, 2, 3]
((2, 1), [2, 1, 3])
也：
Prelude> runState (return 0) 1
(0, 1)
我最喜欢的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”）允许您使用大括号和分号和/或缩进和换行。
解释monad似乎就像解释控制流语句一样。想象一下，一个非程序员要求你解释它们？
你可以给他们一个涉及理论的解释——布尔逻辑、寄存器值、指针、堆栈和框架。但那太疯狂了。
你可以用语法来解释它们。基本上，C中的所有控制流语句都有大括号，您可以通过它们相对于括号的位置来区分条件和条件代码。这可能更疯狂。
或者，您也可以解释循环、if语句、例程、子例程以及可能的协例程。
Monad可以取代相当多的编程技术。语言中有一种特定的语法支持它们，还有一些关于它们的理论。
它们也是函数式程序员使用命令式代码而不承认它的一种方式，但这并不是他们唯一的用途。
如果你要求对如此抽象的东西做出简洁、实用的解释，那么你只能希望得到一个抽象的答案：
a -> b
是表示从as到bs的计算的一种方式。您可以将计算链接起来，也可以将它们组合在一起：
(b -> c) -> (a -> b) -> (a -> c)
更复杂的计算需要更复杂的类型，例如：
a -> f b
是从as到bs到fs的计算类型。您还可以编写它们：
(b -> f c) -> (a -> f b) -> (a -> f c)
事实证明，这种模式无处不在，并且与上面的第一个组合具有相同的财产（结合性、右-和左-同一性）。
人们必须给这个模式起一个名字，但如果知道第一个组合被正式描述为半群体，这会有帮助吗？
“单子和圆括号一样有趣和重要”（奥列格·基斯廖夫）
