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 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)

事实上，与一般人对蒙得斯的理解相反，他们与国家无关。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是一个容器，但用于数据。一个特殊的容器。

所有容器都可以有开口、把手和喷口，但这些容器都保证有一定的开口、把手或喷口。

为什么？因为这些有保证的开口、把手和喷口对于以特定、常见的方式拾取和连接容器非常有用。

这使您可以选择不同的容器，而不必对它们了解太多。它还允许不同类型的容器轻松连接在一起。

monad是一种将共享共同上下文的计算组合在一起的方法。这就像建立一个管道网络。当构建网络时，没有数据流过它。但是当我用“bind”和“return”将所有位拼接在一起后，我调用类似runMyMonad monad数据的东西，数据流过管道。

monad实际上是“类型运算符”的一种形式。它将做三件事。首先，它会将一种类型的值“包装”（或以其他方式转换）为另一种类型（通常称为“一元类型”）。第二，它将使底层类型上的所有操作（或函数）在monadic类型上可用。最后，它将为将自身与另一个monad组合以生成复合monad提供支持。

“可能monad”本质上等同于Visual Basic/C#中的“可为null的类型”。它接受不可为null的类型“T”并将其转换为“可为null＜T＞”，然后定义所有二进制运算符在可为null＞＜T＞上的含义。

副作用也有类似的表现。创建了一个结构，该结构包含函数返回值旁边的副作用描述。当值在函数之间传递时，“提升”操作会复制副作用。

它们被称为“monad”，而不是更容易理解的“类型运算符”的名称，原因如下：

Monad对他们的行为有限制（详见定义）。这些限制，加上涉及三个运算，符合范畴理论中一个叫做monad的结构，这是一个模糊的数学分支。它们是由“纯”函数语言的支持者设计的纯函数语言的支持者，如模糊的数学分支由于数学晦涩难懂，而且monad与特定的编程风格相关，人们倾向于使用monad这个词作为一种秘密握手。正因为如此，没有人费心去投资一个更好的名字。