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

对于来自命令式背景（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和大量关于函数式编程的信息

根据我们所谈论的monad，“什么是monad”这个问题是错误的：

对“什么是单单体？”这个问题的简短回答是，它是内函子范畴中的单单体，或者它是一种通用数据类型，配备了满足某些定律的两个运算。这是正确的，但它并没有揭示一个重要的大局。这是因为问题是错误的。在这篇论文中，我们的目标是回答正确的问题，即“当作者谈论单子时，他们真正说的是什么？”

虽然这篇论文没有直接回答什么是单子，但它有助于理解不同背景的人谈论单子时的含义以及原因。

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

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

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

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

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

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

在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

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      }