让下面的“｛|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”有点像说“什么是数字？”我们总是使用数字。但想象一下，你遇到了一个对数字一无所知的人。你怎么解释数字是什么？你怎么开始描述为什么这可能有用？

什么是单子？简单的回答是：这是一种将操作链接在一起的特定方式。

本质上，您正在编写执行步骤，并将它们与“绑定函数”链接在一起。（在Haskell中，它名为>>=。）您可以自己编写对绑定运算符的调用，也可以使用语法糖，使编译器为您插入这些函数调用。但无论哪种方式，每个步骤都由对该绑定函数的调用分隔。

因此绑定函数就像分号；它将流程中的步骤分开。bind函数的任务是获取上一步的输出，并将其输入下一步。

听起来不太难，对吧？但单子不止一种。为什么？怎样

好吧，bind函数可以从一个步骤中获取结果，并将其传递给下一个步骤。但如果这就是单子的全部。。。这实际上不是很有用。理解这一点很重要：每个有用的monad除了做monad之外，还做其他事情。每一个有用的单子都有一种“特殊的力量”，这使它独一无二。

（没有什么特别作用的monad被称为“身份monad”。与身份函数类似，这听起来是一件毫无意义的事情，但事实证明并非如此……但这是另一回事™.)

基本上，每个monad都有自己的绑定函数实现。你可以编写一个绑定函数，这样它就可以在执行步骤之间做一些傻事。例如：

如果每个步骤都返回一个成功/失败指示符，则只有在前一个步骤成功的情况下，才能让绑定执行下一个步骤。这样，失败的步骤“自动”中止整个序列，而无需您进行任何条件测试。（故障单）扩展这个想法，您可以实现“异常”。（错误单点或异常单点。）因为您自己定义它们，而不是将其作为一种语言特性，所以您可以定义它们的工作方式。（例如，您可能希望忽略前两个异常，仅在引发第三个异常时中止。）您可以使每个步骤返回多个结果，并让bind函数对其进行循环，将每个结果输入到下一步。这样，在处理多个结果时，就不必一直到处写循环。绑定函数“自动”为您完成所有这些。（单子）除了将“结果”从一个步骤传递到另一个步骤之外，还可以让bind函数传递额外的数据。这些数据现在不会显示在源代码中，但您仍然可以从任何地方访问它，而无需手动将其传递给每个函数。（《读者》杂志）您可以这样做，以便可以替换“额外数据”。这允许您模拟破坏性更新，而无需实际执行破坏性更新。（莫纳德州及其堂弟作家莫纳德。）因为您只是在模拟破坏性更新，所以您可以轻松地完成真正的破坏性更新所无法完成的事情。例如，您可以撤消上一次更新，或恢复到旧版本。你可以制作一个可以暂停计算的monad，这样你就可以暂停你的程序，进入并修补内部状态数据，然后恢复它。您可以将“continuations”实现为monad。这可以让你打破人们的想法！

所有这些和更多的都可以通过monad实现。当然，这一切在没有单子的情况下也是完全可能的。使用monad非常简单。

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

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

一个非常简单的答案是：

Monad是一种抽象，它为封装值、计算新的封装值和展开封装值提供了接口。

它们在实践中的方便之处在于，它们提供了一个统一的接口，用于创建建模状态而非状态的数据类型。

必须理解Monad是一种抽象，即用于处理某种数据结构的抽象接口。然后，该接口用于构建具有一元行为的数据类型。

你可以在Ruby中的Monads中找到一个非常好且实用的介绍，第1部分：简介。

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

这是你要找的视频。

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

世界需要的是另一篇monad博客文章，但我认为这对识别野外现存的monad很有用。

单子是分形

上面是一个叫做Sierpinski三角形的分形，这是我唯一记得画的分形。分形是与上述三角形相似的自相似结构，其中部分与整体相似（在这种情况下，正好是母三角形比例的一半）。单子是分形。给定一个一元数据结构，它的值可以组合成数据结构的另一个值。这就是为什么它对编程有用，这也是为什么它在许多情况下都会出现。