事实上，与一般人对蒙得斯的理解相反，他们与国家无关。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这样的语言潜水吧。修道院就是这样一种东西，在那里，通过练习，理解慢慢地进入你的大脑，有一天你突然意识到你理解了它们。

第一：如果你不是数学家，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

http://mikehadlow.blogspot.com/2011/02/monads-in-c-8-video-of-my-ddd9-monad.html

这是你要找的视频。

用C#演示组合和对齐类型的问题，然后用C#正确实现它们。最后，他展示了F#和Haskell中相同的C#代码的外观。

但是，你本可以发明蒙纳斯！

sigfpe说：但所有这些都将单子介绍为需要解释的深奥的东西。但我想说的是，它们一点都不深奥。事实上，面对函数式编程中的各种问题，你会不可避免地被引向某些解决方案，所有这些都是单子的例子。事实上，如果你还没有发明，我希望你现在就发明它们。这是注意到所有这些解决方案实际上都是变相的相同解决方案的一小步。读完这篇文章后，你可能会更好地理解单子上的其他文档，因为你会发现你所看到的一切都是你已经发明的。monads试图解决的许多问题都与副作用有关。因此，我们将从它们开始。（请注意，monad让您做的不仅仅是处理副作用，特别是许多类型的容器对象都可以被视为monad。monad的一些介绍发现，很难协调monad的这两种不同用法，并且只关注其中一种。）在命令式编程语言（如C++）中，函数的行为与数学函数完全不同。例如，假设我们有一个C++函数，它接受一个浮点参数并返回一个浮点结果。从表面上看，它可能有点像一个将实数映射到实数的数学函数，但C++函数可以做的不仅仅是返回一个依赖于其参数的数字。它可以读取和写入全局变量的值，也可以将输出写入屏幕并接收用户的输入。然而，在纯函数语言中，函数只能读取在其参数中提供给它的内容，而它对世界产生影响的唯一方式是通过它返回的值。

让下面的“｛|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接口。