第一：如果你不是数学家，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添加到语言中。

在Coursera“反应式编程原理”培训中，Erik Meier将其描述为：

"Monads are return types that guide you through the happy path." -Erik Meijer

除了上面出色的答案之外，让我为您提供以下文章的链接（由Patrick Thomson撰写），该文章通过将概念与JavaScript库jQuery（及其使用“方法链接”来操作DOM的方式）相关联来解释monads：jQuery是Monad

jQuery文档本身并没有提到术语“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允许在上下文中包含值的函数组合。

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一词。

（另请参见“什么是monad？”中的答案）

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

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

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

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

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