在最近简要回顾了Haskell之后，对于monad本质上是什么，有什么简单、简洁、实用的解释？
我发现，我遇到的大多数解释都很难理解，而且缺乏实际细节。
但是，你本可以发明蒙纳斯！
sigfpe说：但所有这些都将单子介绍为需要解释的深奥的东西。但我想说的是，它们一点都不深奥。事实上，面对函数式编程中的各种问题，你会不可避免地被引向某些解决方案，所有这些都是单子的例子。事实上，如果你还没有发明，我希望你现在就发明它们。这是注意到所有这些解决方案实际上都是变相的相同解决方案的一小步。读完这篇文章后，你可能会更好地理解单子上的其他文档，因为你会发现你所看到的一切都是你已经发明的。monads试图解决的许多问题都与副作用有关。因此，我们将从它们开始。（请注意，monad让您做的不仅仅是处理副作用，特别是许多类型的容器对象都可以被视为monad。monad的一些介绍发现，很难协调monad的这两种不同用法，并且只关注其中一种。）在命令式编程语言（如C++）中，函数的行为与数学函数完全不同。例如，假设我们有一个C++函数，它接受一个浮点参数并返回一个浮点结果。从表面上看，它可能有点像一个将实数映射到实数的数学函数，但C++函数可以做的不仅仅是返回一个依赖于其参数的数字。它可以读取和写入全局变量的值，也可以将输出写入屏幕并接收用户的输入。然而，在纯函数语言中，函数只能读取在其参数中提供给它的内容，而它对世界产生影响的唯一方式是通过它返回的值。
我最喜欢的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是用于封装状态变化的对象的东西。在不允许您具有可修改状态的语言（例如，Haskell）中最常遇到这种情况。
例如文件I/O。
您将能够使用文件I/O的monad来将不断变化的状态本质与使用monad的代码隔离开来。Monad内部的代码可以有效地忽略Monad外部世界的变化状态，这使您更容易理解程序的整体效果。
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？”中的答案）
蒙纳斯的一个很好的动机是西格菲（丹·皮波尼）的《你本可以发明蒙纳斯！（也许你已经有了）。还有很多其他monad教程，其中许多都试图使用各种类比以“简单的术语”来解释monad：这就是monad教程谬论；避开它们。
正如MacIver博士在《告诉我们为什么你的语言很糟糕》中所说：所以，我讨厌Haskell的事情：让我们从显而易见的开始。Monad教程。不，不是单子。特别是教程。他们没完没了，夸夸其谈，亲爱的上帝，他们太乏味了。此外，我从未见过任何令人信服的证据表明它们确实有帮助。阅读类定义，编写一些代码，忘掉这个可怕的名字。
你说你懂“也许莫纳德”吗？很好，你在路上了。只要开始使用其他monad，迟早你会了解monad的一般含义。
（如果你以数学为导向，你可能想忽略几十个教程，学习定义，或遵循类别理论的讲座：）定义的主要部分是Monad M包含一个“类型构造器”，为每个现有类型“T”定义一个新类型“M T”，以及在“常规”类型和“M”类型之间来回移动的一些方式。]
同样，令人惊讶的是，对monad最好的介绍之一实际上是介绍monad的早期学术论文之一，Philip Wadler的Monad for functional programming。它实际上有一些实用的、非平凡的激励性例子，与许多人工教程不同。
如果我理解正确的话，IEnumerable是从monad派生出来的。我想知道，对于我们这些来自C#世界的人来说，这可能是一个有趣的视角吗？
值得一提的是，这里有一些帮助我的教程链接（不，我还不知道单子是什么）。
http://osteele.com/archives/2007/12/overloading-semicolonhttp://spbhug.folding-maps.org/wiki/MonadsEnhttp://www.loria.fr/~kow/monads/
事实上，与一般人对蒙得斯的理解相反，他们与国家无关。Monads只是一种包装东西的方法，它提供了对包装好的东西进行操作而不展开的方法。
例如，您可以在Haskell中创建一个类型来包装另一个类型：
data Wrapped a = Wrap a
包装我们定义的东西
return :: a -> Wrapped a
return x = Wrap x
要在不展开的情况下执行操作，假设您有一个函数f：：a->b，然后您可以执行此操作来提升该函数以作用于包装的值：
fmap :: (a -> b) -> (Wrapped a -> Wrapped b)
fmap f (Wrap x) = Wrap (f x)
这就是所有需要理解的。然而，事实证明，有一个更通用的函数来执行此提升，即bind：
bind :: (a -> Wrapped b) -> (Wrapped a -> Wrapped b)
bind f (Wrap x) = f x
bind可以比fmap做得更多，但反之亦然。实际上，fmap只能用绑定和返回来定义。因此，在定义monad时。。您给出它的类型（这里是Wrapped a），然后说明它的返回和绑定操作是如何工作的。
很酷的是，这是一个普遍的模式，它会在所有地方弹出，以纯方式封装状态只是其中之一。
有关如何使用monad来引入函数依赖关系，从而控制求值顺序（如Haskell的IO monad中所用）的好文章，请查看IOInside。
至于理解单子，不要太担心。读一些你觉得有趣的东西，如果你不马上理解，也不要担心。那就用Haskell这样的语言潜水吧。修道院就是这样一种东西，在那里，通过练习，理解慢慢地进入你的大脑，有一天你突然意识到你理解了它们。
[免责声明：我仍在努力完全了解monads。以下是我目前所了解的情况。如果这是错误的，希望有有知识的人会在地毯上给我打电话。]
Arnar写道：
Monads只是一种包装东西的方法，它提供了对包装好的东西进行操作而不展开的方法。
正是这样。想法是这样的：
你需要一些价值，并用一些附加信息来包装它。就像值是某种类型的（例如整数或字符串）一样，附加信息也是某种类型的。例如，该额外信息可能是“可能”或“IO”。然后，您有一些运算符，允许您在携带附加信息的同时对打包的数据进行操作。这些运算符使用附加信息来决定如何更改包装值上的操作行为。例如，Maybe Int可以是Just Int或Nothing。现在，如果您将Maybe Int添加到Maybe Int，则运算符将检查它们是否都是内部的Just Int，如果是，则将展开Int，将其传递给加法运算符，将生成的Int重新包装为新的Just Int（这是有效的Maybe Int），从而返回Maybe Int。但如果其中一个是内部的Nothing，则该运算符将立即返回Nothing，这也是一个有效的Maybe Int。这样，你可以假装Maybe Ints只是正常的数字，并对它们进行常规运算。如果你得到了一个Nothing，你的方程仍然会产生正确的结果——而不必到处乱检查Nothing。
但这个例子正是Maybe所发生的事情。如果额外的信息是IO，那么将调用为IO定义的特殊运算符，并且在执行添加之前，它可以执行完全不同的操作。（好吧，将两个IO Int加在一起可能是荒谬的——我还不确定。）
基本上，“monad”大致意思是“模式”。但是，您现在有了一种语言构造（语法和所有），可以将新模式声明为程序中的东西，而不是一本充满了非正式解释和专门命名的模式的书。（这里的不精确之处在于所有模式都必须遵循特定的形式，因此monad不像模式那样通用。但我认为这是大多数人都知道和理解的最接近的术语。）
这就是为什么人们觉得单子如此令人困惑：因为它们是一个通用的概念。问是什么使某物成为monad与问是什么让某物成为模式类似。
但是想想在语言中对模式的概念提供语法支持的含义：你不必阅读“四人帮”一书，记住特定模式的构造，只需编写一次代码，以不可知的通用方式实现这个模式，然后就完成了！然后，您可以重用此模式，如Visitor或Strategy或Façade等，只需用它装饰代码中的操作，而无需反复重新实现它！
所以，这就是为什么理解monad的人会发现它们如此有用的原因：这并不是知识势利者以理解为荣的象牙塔概念（好吧，当然也是如此，teehee），而是实际上让代码更简单。
你应该首先了解函子是什么。在此之前，先了解高阶函数。
高阶函数只是一个以函数为自变量的函数。
函子是任何类型构造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，您的代码可能会按顺序运行（如IO monad），同时在多个项目上并行运行（如List monad）；它可能会中途停止（如Maybe monad）。它可能会在中途暂停以稍后恢复（如Resume monad）），或者它可能会中途倒带以尝试其他选项（如逻辑单声道）。
因为monad是多态的，所以可以根据需要在不同的monad中运行相同的代码。
此外，在某些情况下，可以将monad组合在一起（使用monad转换器）以同时获得多个特性。
除了上面出色的答案之外，让我为您提供以下文章的链接（由Patrick Thomson撰写），该文章通过将概念与JavaScript库jQuery（及其使用“方法链接”来操作DOM的方式）相关联来解释monads：jQuery是Monad
jQuery文档本身并没有提到术语“monad”，而是谈到了可能更熟悉的“构建器模式”。这并不能改变一个事实，那就是你有一个合适的monad，也许你甚至没有意识到它。
在了解这些信息时，对我帮助最大的两件事是：
第8章，“函数解析器”，摘自Graham Hutton的《Haskell编程》一书。实际上，这根本没有提到monad，但如果您能够通读第章并真正理解其中的所有内容，特别是如何评估一系列绑定操作，您将了解monad的内部结构。预计这需要多次尝试。
关于修道院的教程。这提供了几个很好的例子来说明它们的用途，我不得不说，我在Appendex中的类比是为我工作的。
Monad用于控制流，就像抽象数据类型用于数据一样。
换句话说，许多开发人员对集合、列表、字典（或哈希、或地图）和树的概念很熟悉。在这些数据类型中有许多特殊情况（例如InsertionOrderPreservingIdentityHashMap）。
然而，当面对程序“流”时，许多开发人员还没有接触到比if、switch/case、do、while、goto（grr）和（可能）闭包更多的构造。
因此，monad只是一个控制流构造。替代monad的更好短语是“控制类型”。
因此，monad具有用于控制逻辑、语句或函数的槽——数据结构中的等价物是，某些数据结构允许您添加数据，并删除数据。
例如，“if”monad：
if( clause ) then block
最简单的是有两个槽：一个子句和一个块。if monad通常用于评估子句的结果，如果不是false，则评估块。许多开发人员在学习“如果”时并没有接触到monad，而且编写有效的逻辑并不需要理解monad。
monad可能会变得更复杂，就像数据结构可能变得更复杂一样，但monad有很多大类可能具有相似的语义，但实现和语法不同。
当然，数据结构可以在单子上迭代或遍历，也可以以同样的方式进行评估。
编译器可能支持也可能不支持用户定义的monad。哈斯克尔当然知道。Ioke有一些类似的功能，尽管语言中没有使用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内部，它只是不需要暴露。
monad是一种将共享共同上下文的计算组合在一起的方法。这就像建立一个管道网络。当构建网络时，没有数据流过它。但是当我用“bind”和“return”将所有位拼接在一起后，我调用类似runMyMonad monad数据的东西，数据流过管道。
经过努力，我想我终于明白了单子。在重新阅读了我自己对绝大多数投票结果的冗长批评之后，我将给出这个解释。
要理解单子，需要回答三个问题：
你为什么需要蒙纳德？什么是单子？如何实现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似乎就像解释控制流语句一样。想象一下，一个非程序员要求你解释它们？
你可以给他们一个涉及理论的解释——布尔逻辑、寄存器值、指针、堆栈和框架。但那太疯狂了。
你可以用语法来解释它们。基本上，C中的所有控制流语句都有大括号，您可以通过它们相对于括号的位置来区分条件和条件代码。这可能更疯狂。
或者，您也可以解释循环、if语句、例程、子例程以及可能的协例程。
Monad可以取代相当多的编程技术。语言中有一种特定的语法支持它们，还有一些关于它们的理论。
它们也是函数式程序员使用命令式代码而不承认它的一种方式，但这并不是他们唯一的用途。
http://mikehadlow.blogspot.com/2011/02/monads-in-c-8-video-of-my-ddd9-monad.html
这是你要找的视频。
用C#演示组合和对齐类型的问题，然后用C#正确实现它们。最后，他展示了F#和Haskell中相同的C#代码的外观。
解释“什么是monad”有点像说“什么是数字？”我们总是使用数字。但想象一下，你遇到了一个对数字一无所知的人。你怎么解释数字是什么？你怎么开始描述为什么这可能有用？
什么是单子？简单的回答是：这是一种将操作链接在一起的特定方式。
本质上，您正在编写执行步骤，并将它们与“绑定函数”链接在一起。（在Haskell中，它名为>>=。）您可以自己编写对绑定运算符的调用，也可以使用语法糖，使编译器为您插入这些函数调用。但无论哪种方式，每个步骤都由对该绑定函数的调用分隔。
因此绑定函数就像分号；它将流程中的步骤分开。bind函数的任务是获取上一步的输出，并将其输入下一步。
听起来不太难，对吧？但单子不止一种。为什么？怎样
好吧，bind函数可以从一个步骤中获取结果，并将其传递给下一个步骤。但如果这就是单子的全部。。。这实际上不是很有用。理解这一点很重要：每个有用的monad除了做monad之外，还做其他事情。每一个有用的单子都有一种“特殊的力量”，这使它独一无二。
（没有什么特别作用的monad被称为“身份monad”。与身份函数类似，这听起来是一件毫无意义的事情，但事实证明并非如此……但这是另一回事™.)
基本上，每个monad都有自己的绑定函数实现。你可以编写一个绑定函数，这样它就可以在执行步骤之间做一些傻事。例如：
如果每个步骤都返回一个成功/失败指示符，则只有在前一个步骤成功的情况下，才能让绑定执行下一个步骤。这样，失败的步骤“自动”中止整个序列，而无需您进行任何条件测试。（故障单）扩展这个想法，您可以实现“异常”。（错误单点或异常单点。）因为您自己定义它们，而不是将其作为一种语言特性，所以您可以定义它们的工作方式。（例如，您可能希望忽略前两个异常，仅在引发第三个异常时中止。）您可以使每个步骤返回多个结果，并让bind函数对其进行循环，将每个结果输入到下一步。这样，在处理多个结果时，就不必一直到处写循环。绑定函数“自动”为您完成所有这些。（单子）除了将“结果”从一个步骤传递到另一个步骤之外，还可以让bind函数传递额外的数据。这些数据现在不会显示在源代码中，但您仍然可以从任何地方访问它，而无需手动将其传递给每个函数。（《读者》杂志）您可以这样做，以便可以替换“额外数据”。这允许您模拟破坏性更新，而无需实际执行破坏性更新。（莫纳德州及其堂弟作家莫纳德。）因为您只是在模拟破坏性更新，所以您可以轻松地完成真正的破坏性更新所无法完成的事情。例如，您可以撤消上一次更新，或恢复到旧版本。你可以制作一个可以暂停计算的monad，这样你就可以暂停你的程序，进入并修补内部状态数据，然后恢复它。您可以将“continuations”实现为monad。这可以让你打破人们的想法！
所有这些和更多的都可以通过monad实现。当然，这一切在没有单子的情况下也是完全可能的。使用monad非常简单。
我也在努力理解单子。这是我的版本：
Monad是关于对重复的事物进行抽象的。首先，monad本身是一个类型化接口（像抽象泛型类），它有两个函数：bind和return，它们定义了签名。然后，我们可以基于抽象的monad创建具体的monad，当然还有绑定和返回的具体实现。此外，绑定和返回必须满足几个不变量，以便可以组合/链接具体的单体。
当我们有接口、类型、类和其他工具来创建抽象时，为什么要创建monad概念？因为monad提供了更多：它们以一种能够在没有任何样板的情况下合成数据的方式强制重新思考问题。
Monoid似乎可以确保在Monoid和受支持的类型上定义的所有操作始终返回Monoid内部的受支持类型。任何数字+任何数字=一个数字，没有错误。
而除法接受两个分数，并返回一个分数，该分数在haskell somewhy中将除以零定义为无穷大（恰好是分数somewhy）。。。
在任何情况下，Monads似乎只是一种确保您的操作链以可预测的方式运行的方法，而一个声称为Num->Num的函数，由另一个用x调用的Num->Num的函数组成，并不意味着发射导弹。
另一方面，如果我们有一个功能可以发射导弹，我们可以将它与其他功能组合起来，也可以发射导弹。
在Haskell中，main的类型是IO（）或IO[（）]，这种区分很奇怪，我不会讨论它，但我认为会发生以下情况：
如果我有main，我希望它做一系列动作，我运行程序的原因是产生一个效果——通常是通过IO。因此，我可以将IO操作串联在一起，以便——做IO，而不是其他。
如果我尝试做一些不“返回IO”的事情，程序会抱怨链不流动，或者基本上“这与我们正在尝试做的事情有什么关系——IO动作”，这似乎迫使程序员保持思路，不偏离并思考发射导弹，同时创建排序算法——不流动。
基本上，Monads似乎是编译器的一个提示，“嘿，你知道这个函数在这里返回一个数字，它实际上并不总是有效的，它有时会产生一个number，有时什么都没有，请记住这一点”。知道了这一点，如果你试图断言一个单元动作，单元动作可能会作为一个编译时异常，说“嘿，这实际上不是一个数字，这可能是一个数字。但你不能假设这一点。做一些事情以确保流是可接受的。”这在一定程度上防止了不可预测的程序行为。
似乎monad不是关于纯粹性，也不是关于控制，而是关于维护一个类别的身份，在这个类别上，所有行为都是可预测和定义的，或者不编译。当你被要求做某事时，你不能什么都不做，如果你被要求什么都不干（可见），你也不能做。
我能想到的Monads的最大原因是——看看程序/OOP代码，你会发现你不知道程序从哪里开始，也不知道程序的结束，你看到的只是大量的跳跃和大量的数学、魔法和导弹。您将无法维护它，如果可以的话，您将花费大量的时间来思考整个程序，然后才能理解其中的任何部分，因为在这种情况下，模块化是基于代码的相互依赖的“部分”，其中代码被优化为尽可能相关，以保证效率/相互关系。单子是非常具体的，并且通过定义得到了很好的定义，并确保程序流程可以进行分析，并隔离难以分析的部分——因为它们本身就是单子。monad似乎是一个“可理解的单元，它在完全理解时是可预测的”——如果你理解“可能”monad，那么它除了“可能”之外就没有可能做任何事情，这看起来微不足道，但在大多数非monad代码中，一个简单的函数“helloworld”可以发射导弹，什么都不做，或者摧毁宇宙，甚至扭曲时间——我们不知道也不能保证它是什么样子。一个单子保证它就是什么样子。这是非常强大的。
“现实世界”中的所有事物似乎都是单子，因为它受到防止混淆的明确可观察规律的约束。这并不意味着我们必须模仿这个对象的所有操作来创建类，相反，我们可以简单地说“一个正方形就是一个正方形”，只不过是一个正方形，甚至不是矩形或圆形，和“一个正方形的面积是它现有维度的长度乘以它自身的面积。无论你有什么正方形，如果它是2D空间中的正方形，它的面积绝对不能是任何东西，只有它的长度平方，这几乎是微不足道的。这是非常强大的，因为我们不需要断言我们的世界是这样的，我们只需要使用现实的含义来预测它。”防止我们的节目偏离轨道。
我几乎可以肯定是错的，但我认为这可以帮助一些人，所以希望它能帮助一些人。
数学思维
简而言之：用于组合计算的代数结构。
返回数据：创建一个只需在monad世界中生成数据的计算。
（return data）>>=（return func）：第二个参数接受第一个参数作为数据生成器，并创建连接它们的新计算。
您可以认为（>>=）和return本身不会进行任何计算。他们只是简单地组合和创建计算。
当且仅当main触发时，任何monad计算都将被计算。
在Coursera“反应式编程原理”培训中，Erik Meier将其描述为：
"Monads are return types that guide you through the happy path." -Erik Meijer
在Scala的上下文中，您会发现以下是最简单的定义。基本上，flatMap（或bind）是“关联”的，并且存在一个标识。
trait M[+A] {
def flatMap[B](f: A => M[B]): M[B] // AKA bind
// Pseudo Meta Code
def isValidMonad: Boolean = {
// for every parameter the following holds
def isAssociativeOn[X, Y, Z](x: M[X], f: X => M[Y], g: Y => M[Z]): Boolean =
x.flatMap(f).flatMap(g) == x.flatMap(f(_).flatMap(g))
// for every parameter X and x, there exists an id
// such that the following holds
def isAnIdentity[X](x: M[X], id: X => M[X]): Boolean =
x.flatMap(id) == x
}
}
E.g.
// These could be any functions
val f: Int => Option[String] = number => if (number == 7) Some("hello") else None
val g: String => Option[Double] = string => Some(3.14)
// Observe these are identical. Since Option is a Monad
// they will always be identical no matter what the functions are
scala> Some(7).flatMap(f).flatMap(g)
res211: Option[Double] = Some(3.14)
scala> Some(7).flatMap(f(_).flatMap(g))
res212: Option[Double] = Some(3.14)
// As Option is a Monad, there exists an identity:
val id: Int => Option[Int] = x => Some(x)
// Observe these are identical
scala> Some(7).flatMap(id)
res213: Option[Int] = Some(7)
scala> Some(7)
res214: Some[Int] = Some(7)
注：严格地说，函数编程中的Monad的定义与范畴理论中的Monard的定义不同，后者是按映射和展平的顺序定义的。尽管它们在某些映射下是等价的。这个演示非常好：http://www.slideshare.net/samthemonad/monad-presentation-scala-as-a-category
我对monads还是个新手，但我想我会分享一个我觉得读起来很好的链接（带图片！！）：http://www.matusiak.eu/numerodix/blog/2012/3/11/monads-for-the-layman/（无隶属关系）
基本上，我从这篇文章中得到的温暖而模糊的概念是monad基本上是适配器，允许不同的函数以可组合的方式工作，即能够将多个函数串起来并混合和匹配它们，而不用担心不一致的返回类型等。因此，当我们尝试制作这些适配器时，BIND函数负责将苹果与苹果、橙子与橙子放在一起。LIFT功能负责使用“较低级别”的功能，并将其“升级”为与BIND功能一起使用并可组合。
我希望我做得对，更重要的是，希望这篇文章对单子有一个有效的观点。如果没有别的话，这篇文章有助于激发我学习更多关于单子叶植物的欲望。
在几年前回答了这个问题之后，我相信我可以通过。。。
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博客文章，但我认为这对识别野外现存的monad很有用。
单子是分形
上面是一个叫做Sierpinski三角形的分形，这是我唯一记得画的分形。分形是与上述三角形相似的自相似结构，其中部分与整体相似（在这种情况下，正好是母三角形比例的一半）。单子是分形。给定一个一元数据结构，它的值可以组合成数据结构的另一个值。这就是为什么它对编程有用，这也是为什么它在许多情况下都会出现。
一个非常简单的答案是：
Monad是一种抽象，它为封装值、计算新的封装值和展开封装值提供了接口。
它们在实践中的方便之处在于，它们提供了一个统一的接口，用于创建建模状态而非状态的数据类型。
必须理解Monad是一种抽象，即用于处理某种数据结构的抽象接口。然后，该接口用于构建具有一元行为的数据类型。
你可以在Ruby中的Monads中找到一个非常好且实用的介绍，第1部分：简介。
这个答案从一个激励性的例子开始，通过这个例子，得出一个单子的例子，并正式定义了“单子”。
考虑伪代码中的这三个函数：
f(<x, messages>) := <x, messages "called f. ">
g(<x, messages>) := <x, messages "called g. ">
wrap(x) := <x, "">
f采用<x，messages>形式的有序对，并返回一个有序对。它保持第一项不变，并在第二项后面附加“called f.”。与g相同。
您可以组合这些函数并获得原始值，以及显示函数调用顺序的字符串：
f(g(wrap(x)))
= f(g(<x, "">))
= f(<x, "called g. ">)
= <x, "called g. called f. ">
您不喜欢f和g负责将自己的日志消息附加到先前的日志信息。（为了论证起见，想象一下，f和g必须对这对中的第二项执行复杂的逻辑，而不是附加字符串。在两个或多个不同的函数中重复这种复杂的逻辑会很痛苦。）
您更喜欢编写更简单的函数：
f(x) := <x, "called f. ">
g(x) := <x, "called g. ">
wrap(x) := <x, "">
但看看当你编写它们时会发生什么：
f(g(wrap(x)))
= f(g(<x, "">))
= f(<<x, "">, "called g. ">)
= <<<x, "">, "called g. ">, "called f. ">
问题是，将一对传递到函数中并不能得到所需的结果。但如果你可以将一对输入到函数中呢：
feed(f, feed(g, wrap(x)))
= feed(f, feed(g, <x, "">))
= feed(f, <x, "called g. ">)
= <x, "called g. called f. ">
将feed（f，m）读为“feed m into f”。要将一对＜x，messages＞输入函数f，需要将x传递给f，从f中获取＜y，messages〕，并返回＜y，message message＞。
feed(f, <x, messages>) := let <y, message> = f(x)
in <y, messages message>
请注意，当您对函数执行三项操作时会发生什么：
首先：如果包装一个值，然后将结果对送入函数：
feed(f, wrap(x))
= feed(f, <x, "">)
= let <y, message> = f(x)
in <y, "" message>
= let <y, message> = <x, "called f. ">
in <y, "" message>
= <x, "" "called f. ">
= <x, "called f. ">
= f(x)
这与将值传递给函数相同。
第二：如果你把一对放进包装里：
feed(wrap, <x, messages>)
= let <y, message> = wrap(x)
in <y, messages message>
= let <y, message> = <x, "">
in <y, messages message>
= <x, messages "">
= <x, messages>
这不会改变这对。
第三：如果定义了一个函数，该函数将x和g（x）输入f：
h(x) := feed(f, g(x))
并向其中输入一对：
feed(h, <x, messages>)
= let <y, message> = h(x)
in <y, messages message>
= let <y, message> = feed(f, g(x))
in <y, messages message>
= let <y, message> = feed(f, <x, "called g. ">)
in <y, messages message>
= let <y, message> = let <z, msg> = f(x)
in <z, "called g. " msg>
in <y, messages message>
= let <y, message> = let <z, msg> = <x, "called f. ">
in <z, "called g. " msg>
in <y, messages message>
= let <y, message> = <x, "called g. " "called f. ">
in <y, messages message>
= <x, messages "called g. " "called f. ">
= feed(f, <x, messages "called g. ">)
= feed(f, feed(g, <x, messages>))
这与将对输入g和将所得对输入f相同。
你有大部分的单子。现在您只需要了解程序中的数据类型。
<x，“称为f”>是什么类型的值？这取决于x是什么类型的值。如果x是t类型的，那么你的对就是“t和字符串对”类型的值了。称之为M型。
M是一个类型构造器：M本身并不表示一个类型，但一旦你用一个类型填空，M _就表示一个。M int是一对int和一个字符串。M字符串是一对字符串和一个字符串。等
恭喜你，你已经创建了monad！
形式上，你的monad是元组＜M，feed，wrap＞。
monad是一个元组＜M，feed，wrap＞，其中：
M是类型构造函数。feed接受一个（函数接受一个t并返回一个M u）和一个M t并返回M u。wrap接受一个v并返回一个M v。
t、 u和v是可以相同也可以不同的任意三种类型。单子满足您为特定单子证明的三个财产：
将包裹的t送入函数与将未包裹的t传入函数相同。形式上：饲料（f，包装（x））=f（x）将M t喂入包装物对M t没有任何影响。形式上：进给（包裹，m）=m将一个M t（称为M）输入一个函数将t传递到g从g得到一个M u（称为n）将n输入f与m进g从g得到n将n输入f形式上：饲料（h，m）=饲料（f，饲料（g，m）），其中h（x）：=饲料（f，g（x））
通常，feed称为bind（在Haskell中为AKA>>=），wrap称为return。
实际上，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解析器组合器库时。（也就是说，根据我的经验）
不要挂断电话：-分类理论-可能是月-莫纳德定律-哈斯克尔- !!!!
解释
当用C#/Java术语解释时，这很简单：
monad是一个接受参数并返回特殊类型的函数。这个monad返回的特殊类型也称为monad。（monad是#1和#2的组合）有一些语法糖可以使调用此函数和类型转换更容易。
实例
monad有助于使函数式程序员的生活更轻松。典型示例：Maye monad接受两个参数，一个值和一个函数。如果传递的值为null，则返回null。否则它将计算函数。如果我们需要一个特殊的返回类型，我们也可以调用这个返回类型Maybe。一个非常粗糙的实现如下所示：
object Maybe(object value, Func<object,object> function)
{
if(value==null)
return null;
return function(value);
}
这在C#中是非常无用的，因为这种语言缺乏使monad有用所需的语法糖。但是monad允许您用函数式编程语言编写更简洁的代码。
通常程序员在链中调用monad，如下所示：
var x = Maybe(x, x2 => Maybe(y, y2 => Add(x2, y2)));
在本例中，只有当x和y都为非null时，才会调用Add方法，否则将返回null。
答复
回答最初的问题：monad是一个函数和一个类型。就像一个特殊接口的实现。
让下面的“｛|a|m｝”表示一些一元数据。宣传以下内容的数据类型：
(I got an a!)
/
{| a |m}
函数f知道如何创建monad，只要它有一个a：
(Hi f! What should I be?)
/
(You?. Oh, you'll be /
that data there.) /
/ / (I got a b.)
| -------------- |
| / |
f a |
|--later-> {| b |m}
在这里，我们看到函数f试图评估monad，但遭到了谴责。
(Hmm, how do I get that a?)
o (Get lost buddy.
o Wrong type.)
o /
f {| a |m}
函数f通过使用>>=找到提取a的方法。
(Muaahaha. How you
like me now!?)
(Better.) \
| (Give me that a.)
(Fine, well ok.) |
\ |
{| a |m} >>= f
殊不知，monad和>>=勾结在一起。
(Yah got an a for me?)
(Yeah, but hey |
listen. I got |
something to |
tell you first |
...) \ /
| /
{| a |m} >>= f
但他们实际上在谈论什么？嗯，这取决于单子。仅仅抽象地谈论用处有限；你必须对特定的单子有一些经验，才能充实理解。
例如，数据类型Maybe
data Maybe a = Nothing | Just a
有一个monad实例，其行为如下。。。
其中，如果情况只是
(Yah what is it?)
(... hm? Oh, |
forget about it. |
Hey a, yr up.) |
\ |
(Evaluation \ |
time already? \ |
Hows my hair?) | |
| / |
| (It's |
| fine.) /
| / /
{| a |m} >>= f
但对于Nothing的情况
(Yah what is it?)
(... There |
is no a. ) |
| (No a?)
(No a.) |
| (Ok, I'll deal
| with this.)
\ |
\ (Hey f, get lost.)
\ | ( Where's my a?
\ | I evaluate a)
\ (Not any more |
\ you don't. |
| We're returning
| Nothing.) /
| | /
| | /
| | /
{| a |m} >>= f (I got a b.)
| (This is \
| such a \
| sham.) o o \
| o|
|--later-> {| b |m}
因此，如果Maye monad实际上包含它所宣传的a，则它允许计算继续，但如果不包含，则中止计算。然而，结果仍然是一段单元数据，尽管不是f的输出。因此，Maye monad用于表示失败的上下文。
不同的单子叶植物表现不同。列表是具有一元实例的其他类型的数据。它们的行为如下：
(Ok, here's your a. Well, its
a bunch of them, actually.)
|
| (Thanks, no problem. Ok
| f, here you go, an a.)
| |
| | (Thank's. See
| | you later.)
| (Whoa. Hold up f, |
| I got another |
| a for you.) |
| | (What? No, sorry.
| | Can't do it. I
| | have my hands full
| | with all these "b"
| | I just made.)
| (I'll hold those, |
| you take this, and /
| come back for more /
| when you're done /
| and we'll do it /
| again.) /
\ | ( Uhhh. All right.)
\ | /
\ \ /
{| a |m} >>= f
在这种情况下，该函数知道如何从其输入生成列表，但不知道如何处理额外的输入和额外的列表。bind>>=，通过组合多个输出帮助f。我通过这个例子来说明，当>>=负责提取a时，它也可以访问f的最终绑定输出。事实上，除非它知道最终输出具有相同类型的上下文，否则它永远不会提取任何a。
还有其他monad用于表示不同的上下文。下面是一些其他特征。IO monad实际上没有a，但它认识一个人，会为你拿到a。州立大学圣莫尼德分校有一个秘密的圣莫尼德，它会把圣莫尼德藏在桌子下面给f，尽管f只是来要求一个a。
所有这一切的关键是，任何类型的数据如果声明自己是Monad，都会声明某种上下文来从Monad中提取值。从这一切中获得的巨大收益？好吧，用某种上下文来进行计算是很容易的。然而，当将多个上下文负载的计算串联在一起时，可能会变得混乱。monad操作负责解决上下文的交互，因此程序员不必这样做。
注意，>>=的使用通过从f中移除一些自主权来缓解混乱。也就是说，例如，在上面的Nothing情况下，f不再能够决定在Nothing的情况下要做什么；它被编码为>>=。这就是权衡。如果f有必要决定在Nothing的情况下做什么，那么f应该是从Maybe a到Maybe b的函数。在这种情况下，也许是monad是无关紧要的。
然而，请注意，有时数据类型不会导出它的构造函数（看看你的IO），如果我们想使用广告值，我们别无选择，只能使用它的monadic接口。
另一种尝试是解释monad，只使用Python列表和map函数。我完全接受这不是一个完整的解释，但我希望它能触及核心概念。
我从Monads上的funfunfunction视频和Learn You A Haskell章节“为了几个Monads更多”中得到了这一点的基础。我强烈推荐观看funfunfunction视频。
最简单的是，Monad是具有map和flatMap函数（在Haskell中绑定）的对象。有一些额外的必需财产，但这些是核心属性。
flatMap“展平”map的输出，对于列表，这只是连接列表的值，例如。
concat([[1], [4], [9]]) = [1, 4, 9]
因此，在Python中，我们基本上可以通过以下两个函数实现Monad：
def flatMap(func, lst):
return concat(map(func, lst))
def concat(lst):
return sum(lst, [])
func是任何接受值并返回列表的函数。
lambda x: [x*x]
解释
为了清楚起见，我通过一个简单的函数在Python中创建了concat函数，该函数将列表相加，即[]+[1]+[4]+[9]=[1，4，9]（Haskell有一个原生的concat方法）。
我假设你知道地图功能是什么，例如：
>>> list(map(lambda x: [x*x], [1,2,3]))
[[1], [4], [9]]
展平是Monad的关键概念，对于每个作为Monad的对象，这种展平允许您获得Monad中包裹的值。
现在我们可以呼叫：
>>> flatMap(lambda x: [x*x], [1,2,3])
[1, 4, 9]
这个lambda取一个值x并将其放入一个列表中。monad适用于从值到monad类型的任何函数，所以在本例中是列表。
这是你的monad定义。
我认为为什么它们有用的问题已经在其他问题中得到了回答。
更多说明
其他不是列表的例子有JavaScript Promise，它有then方法，JavaScript Streams有flatMap方法。
因此Promise和Streams使用了一个稍微不同的函数，它将Stream或Promise展平，并从内部返回值。
Haskell列表monad具有以下定义：
instance Monad [] where
return x = [x]
xs >>= f = concat (map f xs)
fail _ = []
即有三个函数return（不要与大多数其他语言中的return混淆）、>>=（flatMap）和fail。
希望您能看到以下两者之间的相似之处：
xs >>= f = concat (map f xs)
and:
def flatMap(f, xs):
return concat(map(f, xs))
我将尝试在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允许在上下文中包含值的函数组合。
tl；博士
{-# LANGUAGE InstanceSigs #-}
newtype Id t = Id t
instance Monad Id where
return :: t -> Id t
return = Id
(=<<) :: (a -> Id b) -> Id a -> Id b
f =<< (Id x) = f x
开场白
应用程序运算符$of函数
forall a b. a -> b
是规范定义的
($) :: (a -> b) -> a -> b
f $ x = f x
infixr 0 $
根据Haskell基函数应用f x（infixl 10）。
作文定义为$as
(.) :: (b -> c) -> (a -> b) -> (a -> c)
f . g = \ x -> f $ g x
infixr 9 .
并且满足所有f g h的等价性。
f . id = f :: c -> d Right identity
id . g = g :: b -> c Left identity
(f . g) . h = f . (g . h) :: a -> d Associativity
.是关联的，id是它的右标识和左标识。
克莱斯利三人组
在编程中，monad是带有monad类型类实例的函子类型构造函数。定义和实现有几个等价的变体，每个变体对monad抽象的直觉略有不同。
函子是带有函子类型类实例的*->*类型的类型构造函数f。
{-# LANGUAGE KindSignatures #-}
class Functor (f :: * -> *) where
map :: (a -> b) -> (f a -> f b)
除了遵循静态强制类型协议之外，函子类型类的实例必须遵守所有f g的代数函子定律。
map id = id :: f t -> f t Identity
map f . map g = map (f . g) :: f a -> f c Composition / short cut fusion
函数计算具有以下类型
forall f t. Functor f => f t
计算c r包含上下文c中的结果r。
一元一元函数或Kleisli箭头的类型为
forall m a b. Functor m => a -> m b
Kleisi箭头是接受一个参数a并返回一元计算m b的函数。
Monads是用Kleisli三重函数定义的
(m, return, (=<<))
实现为类型类
class Functor m => Monad m where
return :: t -> m t
(=<<) :: (a -> m b) -> m a -> m b
infixr 1 =<<
Kleisli标识返回是一个Kleisli箭头，它将值t提升为单元上下文m。
Kleisli组成<=<根据扩展定义为
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> (a -> m c)
f <=< g = \ x -> f =<< g x
infixr 1 <=<
<=<组成两个Kleisli箭头，将左箭头应用于右箭头应用的结果。
monad类型类的实例必须遵守monad定律，这在Kleisli组合中最为优雅地表述为：forall f g h。
f <=< return = f :: c -> m d Right identity
return <=< g = g :: b -> m c Left identity
(f <=< g) <=< h = f <=< (g <=< h) :: a -> m d Associativity
<=<是关联的，返回是它的右标识和左标识。
身份
标识类型
type Id t = t
是类型上的标识函数
Id :: * -> *
被解释为函子，
return :: t -> Id t
= id :: t -> t
(=<<) :: (a -> Id b) -> Id a -> Id b
= ($) :: (a -> b) -> a -> b
(<=<) :: (b -> Id c) -> (a -> Id b) -> (a -> Id c)
= (.) :: (b -> c) -> (a -> b) -> (a -> c)
在规范的Haskell中，定义了身份monad
newtype Id t = Id t
instance Functor Id where
map :: (a -> b) -> Id a -> Id b
map f (Id x) = Id (f x)
instance Monad Id where
return :: t -> Id t
return = Id
(=<<) :: (a -> Id b) -> Id a -> Id b
f =<< (Id x) = f x
选项
选项类型
data Maybe t = Nothing | Just t
编码计算可能t不一定产生结果t，计算可能“失败”。选项monad已定义
instance Functor Maybe where
map :: (a -> b) -> (Maybe a -> Maybe b)
map f (Just x) = Just (f x)
map _ Nothing = Nothing
instance Monad Maybe where
return :: t -> Maybe t
return = Just
(=<<) :: (a -> Maybe b) -> Maybe a -> Maybe b
f =<< (Just x) = f x
_ =<< Nothing = Nothing
a->Maybe b仅在Maybe a产生结果时应用于结果。
newtype Nat = Nat Int
自然数可以编码为大于或等于零的整数。
toNat :: Int -> Maybe Nat
toNat i | i >= 0 = Just (Nat i)
| otherwise = Nothing
自然数在减法下不是封闭的。
(-?) :: Nat -> Nat -> Maybe Nat
(Nat n) -? (Nat m) = toNat (n - m)
infixl 6 -?
选项monad涵盖了异常处理的基本形式。
(-? 20) <=< toNat :: Int -> Maybe Nat
List
列表monad，覆盖列表类型
data [] t = [] | t : [t]
infixr 5 :
及其加法幺半群运算“append”
(++) :: [t] -> [t] -> [t]
(x : xs) ++ ys = x : xs ++ ys
[] ++ ys = ys
infixr 5 ++
编码非线性计算[t]，产生自然量0，1。。。结果t。
instance Functor [] where
map :: (a -> b) -> ([a] -> [b])
map f (x : xs) = f x : map f xs
map _ [] = []
instance Monad [] where
return :: t -> [t]
return = (: [])
(=<<) :: (a -> [b]) -> [a] -> [b]
f =<< (x : xs) = f x ++ (f =<< xs)
_ =<< [] = []
Extension=<<将从Kleisli箭头a->[b]的应用f x到[a]的元素的所有列表[b]连接到一个结果列表[b]。
设正整数n的正除数为
divisors :: Integral t => t -> [t]
divisors n = filter (`divides` n) [2 .. n - 1]
divides :: Integral t => t -> t -> Bool
(`divides` n) = (== 0) . (n `rem`)
then
forall n. let { f = f <=< divisors } in f n = []
在定义monad类型类时，Haskell标准使用其flip，即绑定运算符>>=，而不是extension=<<。
class Applicative m => Monad m where
(>>=) :: forall a b. m a -> (a -> m b) -> m b
(>>) :: forall a b. m a -> m b -> m b
m >> k = m >>= \ _ -> k
{-# INLINE (>>) #-}
return :: a -> m a
return = pure
为了简单起见，本解释使用了类型类层次结构
class Functor f
class Functor m => Monad m
在Haskell中，当前的标准层次结构是
class Functor f
class Functor p => Applicative p
class Applicative m => Monad m
因为不仅每个单子都是函子，而且每个应用格也是函子，每个单子也是应用格。
使用列表monad，命令式伪代码
for a in (1, ..., 10)
for b in (1, ..., 10)
p <- a * b
if even(p)
yield p
大致翻译为do块，
do a <- [1 .. 10]
b <- [1 .. 10]
let p = a * b
guard (even p)
return p
等效的monad理解，
[ p | a <- [1 .. 10], b <- [1 .. 10], let p = a * b, even p ]
和表达式
[1 .. 10] >>= (\ a ->
[1 .. 10] >>= (\ b ->
let p = a * b in
guard (even p) >> -- [ () | even p ] >>
return p
)
)
Do符号和monad理解是嵌套绑定表达式的语法糖。绑定运算符用于一元结果的本地名称绑定。
let x = v in e = (\ x -> e) $ v = v & (\ x -> e)
do { r <- m; c } = (\ r -> c) =<< m = m >>= (\ r -> c)
哪里
(&) :: a -> (a -> b) -> b
(&) = flip ($)
infixl 0 &
定义了防护功能
guard :: Additive m => Bool -> m ()
guard True = return ()
guard False = fail
其中单位类型或“空元组”
data () = ()
支持选择和失败的加法单子可以通过使用类型类抽象
class Monad m => Additive m where
fail :: m t
(<|>) :: m t -> m t -> m t
infixl 3 <|>
instance Additive Maybe where
fail = Nothing
Nothing <|> m = m
m <|> _ = m
instance Additive [] where
fail = []
(<|>) = (++)
其中fail和<|>形成所有k l m的幺半群。
k <|> fail = k
fail <|> l = l
(k <|> l) <|> m = k <|> (l <|> m)
失败的是吸收/消灭零元素的加法单体
_ =<< fail = fail
如果在
guard (even p) >> return p
即使p为真，则保护产生[（）]，并且根据>>的定义，产生局部常数函数
\ _ -> return p
应用于结果（）。如果为false，则保护生成列表monad的fail（[]），这不会产生要应用>>的Kleisli箭头的结果，因此跳过此p。
状态
不光彩的是，monad用于编码有状态计算。
状态处理器是一种功能
forall st t. st -> (t, st)
转换状态st并产生结果t。状态st可以是任何东西。没有，标志，计数，数组，句柄，机器，世界。
状态处理器的类型通常称为
type State st t = st -> (t, st)
状态处理器monad是kind*->*函子state st.Kleisli状态处理器mond的箭头是函数
forall st a b. a -> (State st) b
在规范的Haskell中，定义了状态处理器monad的惰性版本
newtype State st t = State { stateProc :: st -> (t, st) }
instance Functor (State st) where
map :: (a -> b) -> ((State st) a -> (State st) b)
map f (State p) = State $ \ s0 -> let (x, s1) = p s0
in (f x, s1)
instance Monad (State st) where
return :: t -> (State st) t
return x = State $ \ s -> (x, s)
(=<<) :: (a -> (State st) b) -> (State st) a -> (State st) b
f =<< (State p) = State $ \ s0 -> let (x, s1) = p s0
in stateProc (f x) s1
状态处理器通过提供初始状态来运行：
run :: State st t -> st -> (t, st)
run = stateProc
eval :: State st t -> st -> t
eval = fst . run
exec :: State st t -> st -> st
exec = snd . run
状态访问由原语get和put提供，它们是对有状态monad的抽象方法：
{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}
class Monad m => Stateful m st | m -> st where
get :: m st
put :: st -> m ()
m->st声明状态类型st对monad m的函数依赖性；例如，状态t将确定状态类型为t唯一。
instance Stateful (State st) st where
get :: State st st
get = State $ \ s -> (s, s)
put :: st -> State st ()
put s = State $ \ _ -> ((), s)
单位类型类似于C中的空隙。
modify :: Stateful m st => (st -> st) -> m ()
modify f = do
s <- get
put (f s)
gets :: Stateful m st => (st -> t) -> m t
gets f = do
s <- get
return (f s)
gets通常与记录字段访问器一起使用。
状态monad等价于变量线程
let s0 = 34
s1 = (+ 1) s0
n = (* 12) s1
s2 = (+ 7) s1
in (show n, s2)
其中s0：：Int，是同样透明的，但更加优雅和实用
(flip run) 34
(do
modify (+ 1)
n <- gets (* 12)
modify (+ 7)
return (show n)
)
modify（+1）是一种类型为State Int（）的计算，但其效果等同于return（）。
(flip run) 34
(modify (+ 1) >>
gets (* 12) >>= (\ n ->
modify (+ 7) >>
return (show n)
)
)
结合性的单子定律可以用>>=forall m f g来表示。
(m >>= f) >>= g = m >>= (\ x -> f x >>= g)
or
do { do { do {
r1 <- do { x <- m; r0 <- m;
r0 <- m; = do { = r1 <- f r0;
f r0 r1 <- f x; g r1
}; g r1 }
g r1 }
} }
与面向表达式的编程（例如Rust）一样，块的最后一条语句表示其产量。绑定运算符有时被称为“可编程分号”。
对结构化命令式编程中的迭代控制结构原语进行单点仿真
for :: Monad m => (a -> m b) -> [a] -> m ()
for f = foldr ((>>) . f) (return ())
while :: Monad m => m Bool -> m t -> m ()
while c m = do
b <- c
if b then m >> while c m
else return ()
forever :: Monad m => m t
forever m = m >> forever m
输入/输出
data World
I/O世界状态处理器monad是纯Haskell和真实世界的协调，是功能外延和命令式操作语义的协调。与实际严格执行情况类似：
type IO t = World -> (t, World)
不纯洁的原语促进了交互
getChar :: IO Char
putChar :: Char -> IO ()
readFile :: FilePath -> IO String
writeFile :: FilePath -> String -> IO ()
hSetBuffering :: Handle -> BufferMode -> IO ()
hTell :: Handle -> IO Integer
. . . . . .
使用IO原语的代码的杂质由类型系统永久协议化。因为纯净是可怕的，在IO中发生的一切，都留在IO中。
unsafePerformIO :: IO t -> t
或者，至少应该。
Haskell程序的类型签名
main :: IO ()
main = putStrLn "Hello, World!"
扩展到
World -> ((), World)
改变世界的函数。
后记
对象是Haskell类型，态射是Haskelr类型之间的函数的类别是，“快速和松散”，类别是Hask。
函子T是从范畴C到范畴D的映射；对于C中的每个对象，D中的一个对象
Tobj : Obj(C) -> Obj(D)
f :: * -> *
对于C中的每个态射，D中的一个态射
Tmor : HomC(X, Y) -> HomD(Tobj(X), Tobj(Y))
map :: (a -> b) -> (f a -> f b)
其中X，Y是C中的对象。HomC（X，Y）是C中所有态射X->Y的同态类。
Tmor Tobj
T(id) = id : T(X) -> T(X) Identity
T(f) . T(g) = T(f . g) : T(X) -> T(Z) Composition
范畴C的Kleisli范畴由Kleisli三元组给出
<T, eta, _*>
内函子的
T : C -> C
（f） 、同一态射eta（return）和扩展运算符*（=<<）。
Hask中的每个Kleisli态射
f : X -> T(Y)
f :: a -> m b
由扩展运算符
(_)* : Hom(X, T(Y)) -> Hom(T(X), T(Y))
(=<<) :: (a -> m b) -> (m a -> m b)
在Hask的Kleisli范畴中给出了一个态射
f* : T(X) -> T(Y)
(f =<<) :: m a -> m b
Kleisli范畴中的成分。T以扩展的形式给出
f .T g = f* . g : X -> T(Z)
f <=< g = (f =<<) . g :: a -> m c
并且满足范畴公理
eta .T g = g : Y -> T(Z) Left identity
return <=< g = g :: b -> m c
f .T eta = f : Z -> T(U) Right identity
f <=< return = f :: c -> m d
(f .T g) .T h = f .T (g .T h) : X -> T(U) Associativity
(f <=< g) <=< h = f <=< (g <=< h) :: a -> m d
应用等价变换
eta .T g = g
eta* . g = g By definition of .T
eta* . g = id . g forall f. id . f = f
eta* = id forall f g h. f . h = g . h ==> f = g
(f .T g) .T h = f .T (g .T h)
(f* . g)* . h = f* . (g* . h) By definition of .T
(f* . g)* . h = f* . g* . h . is associative
(f* . g)* = f* . g* forall f g h. f . h = g . h ==> f = g
在扩展方面是规范给出的
eta* = id : T(X) -> T(X) Left identity
(return =<<) = id :: m t -> m t
f* . eta = f : Z -> T(U) Right identity
(f =<<) . return = f :: c -> m d
(f* . g)* = f* . g* : T(X) -> T(Z) Associativity
(((f =<<) . g) =<<) = (f =<<) . (g =<<) :: m a -> m c
Monads也可以不使用Kleislian扩展来定义，而是在称为join的编程中使用自然转换mu来定义。一个单元是用μ来定义的，它是一个内函子的范畴C上的三元组
T : C -> C
f :: * -> *
和两种自然变形
eta : Id -> T
return :: t -> f t
mu : T . T -> T
join :: f (f t) -> f t
满足等效条件
mu . T(mu) = mu . mu : T . T . T -> T . T Associativity
join . map join = join . join :: f (f (f t)) -> f t
mu . T(eta) = mu . eta = id : T -> T Identity
join . map return = join . return = id :: f t -> f t
然后定义monad类型类
class Functor m => Monad m where
return :: t -> m t
join :: m (m t) -> m t
选项monad的规范mu实现：
instance Monad Maybe where
return = Just
join (Just m) = m
join Nothing = Nothing
concat函数
concat :: [[a]] -> [a]
concat (x : xs) = x ++ concat xs
concat [] = []
是列表monad的连接。
instance Monad [] where
return :: t -> [t]
return = (: [])
(=<<) :: (a -> [b]) -> ([a] -> [b])
(f =<<) = concat . map f
联接的实现可以使用等价项从扩展形式转换
mu = id* : T . T -> T
join = (id =<<) :: m (m t) -> m t
从mu到扩展形式的反向转换如下
f* = mu . T(f) : T(X) -> T(Y)
(f =<<) = join . map f :: m a -> m b
Philip Wadler:函数编程的MonadsSimon L Peyton Jones，Philip Wadler：强制函数式编程Jonathan M.D.Hill，Keith Clarke：范畴理论、范畴理论单子及其与函数编程的关系简介´Kleisli类别Eugenio Moggi：计算和单子的概念莫纳德不是什么
但为什么如此抽象的理论对编程有用呢？答案很简单：作为计算机科学家，我们重视抽象！当我们设计软件组件的接口时，我们希望它尽可能少地揭示实现。我们希望能够用许多替代方案来替代实现，许多其他“实例”都是相同的“概念”。当我们为许多程序库设计通用接口时，更重要的是我们选择的接口具有多种实现。我们非常重视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)
事实证明，这种模式无处不在，并且与上面的第一个组合具有相同的财产（结合性、右-和左-同一性）。
人们必须给这个模式起一个名字，但如果知道第一个组合被正式描述为半群体，这会有帮助吗？
“单子和圆括号一样有趣和重要”（奥列格·基斯廖夫）
遵循您简短、简洁、实用的指示：
理解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是一种带有特殊机器的盒子，它允许你从两个嵌套的盒子中制作一个普通的盒子，但仍然保持两个盒子的一些形状。
具体来说，它允许您执行连接，类型为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是一个可应用的（即，你可以将二进制（因此，“n元”）函数提升到（1），并将纯值注入（2））Functor（即，可以映射到（3）的函数，即提升一元函数到（3”），它还具有展平嵌套数据类型的能力（三个概念中的每一个都遵循其相应的一组规则）。在Haskell中，这种扁平化操作称为join。
此“联接”操作的常规（通用、参数化）类型为：
join :: Monad m => m (m a) -> m a
对于任何monad m（注意，类型中的所有ms都是相同的！）。
特定的m monad定义了其特定版本的join，该版本适用于由类型m A的monadic值“携带”的任何值类型A。某些特定类型包括：
join :: [[a]] -> [a] -- for lists, or nondeterministic values
join :: Maybe (Maybe a) -> Maybe a -- for Maybe, or optional values
join :: IO (IO a) -> IO a -- for I/O-produced values
连接操作将产生a型值的m计算的m计算转换为a型值组合的m计算。这允许将计算步骤组合成一个更大的计算。
结合“bind”（>>=）运算符的计算步骤简单地使用fmap和join，即。
(ma >>= k) == join (fmap k ma)
{-
ma :: m a -- `m`-computation which produces `a`-type values
k :: a -> m b -- create new `m`-computation from an `a`-type value
fmap k ma :: m ( m b ) -- `m`-computation of `m`-computation of `b`-type values
(m >>= k) :: m b -- `m`-computation which produces `b`-type values
-}
相反，可以通过bind定义join，join mma==join（fmap id mma）==mma>>=id，其中id ma=ma——对于给定的类型m，以更方便的为准。
对于monad，do表示法及其使用代码的等效绑定，
do { x <- mx ; y <- my ; return (f x y) } -- x :: a , mx :: m a
-- y :: b , my :: m b
mx >>= (\x -> -- nested
my >>= (\y -> -- lambda
return (f x y) )) -- functions
可以读为
首先“做”mx，当它完成时，将其“结果”作为x，让我用它“做”其他事情。
在给定的do块中，绑定箭头<-右侧的每个值对于某些类型a都是m a类型，在整个do块中都是相同的monad m。
返回x是一个中立的m计算，它只产生给定的纯值x，因此将任何m计算与返回绑定都不会改变该计算。
（1） 提升A2：：适用m=>（a->b->c）->m a->m b->m c
（2） 纯：：适用m=>a->m a
（3） 具有fmap：：函数m=>（a->b）->m a->m b
还有等效的Monad方法，
liftM2 :: Monad m => (a -> b -> c) -> m a -> m b -> m c
return :: Monad m => a -> m a
liftM :: Monad m => (a -> b) -> m a -> m b
给定monad，其他定义可以如下
pure a = return a
fmap f ma = do { a <- ma ; return (f a) }
liftA2 f ma mb = do { a <- ma ; b <- mb ; return (f a b) }
(ma >>= k) = do { a <- ma ; b <- k a ; return b }
根据我们所谈论的monad，“什么是monad”这个问题是错误的：
对“什么是单单体？”这个问题的简短回答是，它是内函子范畴中的单单体，或者它是一种通用数据类型，配备了满足某些定律的两个运算。这是正确的，但它并没有揭示一个重要的大局。这是因为问题是错误的。在这篇论文中，我们的目标是回答正确的问题，即“当作者谈论单子时，他们真正说的是什么？”
虽然这篇论文没有直接回答什么是单子，但它有助于理解不同背景的人谈论单子时的含义以及原因。
monad是一个容器，但用于数据。一个特殊的容器。
所有容器都可以有开口、把手和喷口，但这些容器都保证有一定的开口、把手或喷口。
为什么？因为这些有保证的开口、把手和喷口对于以特定、常见的方式拾取和连接容器非常有用。
这使您可以选择不同的容器，而不必对它们了解太多。它还允许不同类型的容器轻松连接在一起。
对于来自命令式背景（c#）的人，
考虑以下代码
bool ReturnTrueorFalse(SomeObject input)
{
if(input.Property1 is invalid)
{
return false;
}
if(input.Property2 is invalid)
{
return false;
}
DoSomething();
return true;
}
您会看到很多这样的代码，甚至不会看到早期返回，但所有检查都是嵌套完成的。现在，Monad是一种模式，它可以像下面一样被压平
Monad<bool> ReturnTrueorFalse(SomeObject input) =>
from isProperty1Valid in input.Property1
from isProperty2Valid in input.Property2
select Monad.Create(isProperty1Valid && isProperty2Valid);
这里有几点需要注意。首先，更改函数的返回值。其次，输入的两个财产都必须是Monad。接下来，Monad应该实现SelectMany（LINQ的展平运算符）。由于SelectMany是为该类型实现的，因此可以使用查询语法编写语句
那幺，什么是莫纳德？它是一种以可组合方式对返回相同类型的表达式进行扁平化的结构。这在函数式编程中特别有用，因为大多数函数式应用程序倾向于将状态和IO保持在应用程序的边缘层（例如：控制器），并在整个调用堆栈中返回基于Monad的返回值，直到需要解包该值。当我第一次看到这张照片时，我最大的优点是它很容易在眼睛上看到，也很有陈腔滥调。
每个c#（现在几乎每个人）开发人员都能立即识别的Monad的最佳示例是async/await。在.Net4.5之前，我们必须使用ContinueWith编写基于任务的语句来处理回调，在async/await之后，我们开始使用同步语法来处理异步语法。这是可能的，因为Task是一个“monad”。
关于OOP开发人员的详细说明，请参阅本文，这是一个简单的实现和语言文本，其中包含许多很棒的Monad和大量关于函数式编程的信息
