我最喜欢的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？”中的答案）

蒙纳斯的一个很好的动机是西格菲（丹·皮波尼）的《你本可以发明蒙纳斯！（也许你已经有了）。还有很多其他monad教程，其中许多都试图使用各种类比以“简单的术语”来解释monad：这就是monad教程谬论；避开它们。

正如MacIver博士在《告诉我们为什么你的语言很糟糕》中所说：所以，我讨厌Haskell的事情：让我们从显而易见的开始。Monad教程。不，不是单子。特别是教程。他们没完没了，夸夸其谈，亲爱的上帝，他们太乏味了。此外，我从未见过任何令人信服的证据表明它们确实有帮助。阅读类定义，编写一些代码，忘掉这个可怕的名字。

你说你懂“也许莫纳德”吗？很好，你在路上了。只要开始使用其他monad，迟早你会了解monad的一般含义。

（如果你以数学为导向，你可能想忽略几十个教程，学习定义，或遵循类别理论的讲座：）定义的主要部分是Monad M包含一个“类型构造器”，为每个现有类型“T”定义一个新类型“M T”，以及在“常规”类型和“M”类型之间来回移动的一些方式。]

同样，令人惊讶的是，对monad最好的介绍之一实际上是介绍monad的早期学术论文之一，Philip Wadler的Monad for functional programming。它实际上有一些实用的、非平凡的激励性例子，与许多人工教程不同。

在几年前回答了这个问题之后，我相信我可以通过。。。

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。

monad是一种具有两个操作的数据类型：>>=（又名bind）和return（又名unit）。return接受一个任意值并用它创建monad的实例。>>=接受monad的一个实例并在其上映射一个函数。（您已经可以看到monad是一种奇怪的数据类型，因为在大多数编程语言中，您无法编写一个接受任意值并从中创建类型的函数。monad使用一种参数多态性。）

在Haskell表示法中，monad接口是

class Monad m where
  return :: a -> m a
  (>>=) :: forall a b . m a -> (a -> m b) -> m b

这些操作应该遵守某些“法则”，但这并不是非常重要的：“法则”只是将操作的合理实现行为化（基本上，>>=和return应该就如何将值转换为monad实例达成一致，并且>>=是关联的）。

Monad不仅仅是关于状态和I/O：它们抽象了一种常见的计算模式，包括处理状态、I/O、异常和非确定性。可能最容易理解的单子是列表和选项类型：

instance Monad [ ] where
    []     >>= k = []
    (x:xs) >>= k = k x ++ (xs >>= k)
    return x     = [x]

instance Monad Maybe where
    Just x  >>= k = k x
    Nothing >>= k = Nothing
    return x      = Just x

其中[]和：是列表构造函数，++是串联运算符，Just和Nothing是Maybe构造函数。这两个monad都在各自的数据类型上封装了常见的有用的计算模式（请注意，两者都与副作用或I/O无关）。

你真的需要写一些非平凡的Haskell代码来理解monad的含义以及它们为什么有用。

monad实际上是“类型运算符”的一种形式。它将做三件事。首先，它会将一种类型的值“包装”（或以其他方式转换）为另一种类型（通常称为“一元类型”）。第二，它将使底层类型上的所有操作（或函数）在monadic类型上可用。最后，它将为将自身与另一个monad组合以生成复合monad提供支持。

“可能monad”本质上等同于Visual Basic/C#中的“可为null的类型”。它接受不可为null的类型“T”并将其转换为“可为null＜T＞”，然后定义所有二进制运算符在可为null＞＜T＞上的含义。

副作用也有类似的表现。创建了一个结构，该结构包含函数返回值旁边的副作用描述。当值在函数之间传递时，“提升”操作会复制副作用。

它们被称为“monad”，而不是更容易理解的“类型运算符”的名称，原因如下：

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允许在上下文中包含值的函数组合。