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还是个新手，但我想我会分享一个我觉得读起来很好的链接（带图片！！）：http://www.matusiak.eu/numerodix/blog/2012/3/11/monads-for-the-layman/（无隶属关系）

基本上，我从这篇文章中得到的温暖而模糊的概念是monad基本上是适配器，允许不同的函数以可组合的方式工作，即能够将多个函数串起来并混合和匹配它们，而不用担心不一致的返回类型等。因此，当我们尝试制作这些适配器时，BIND函数负责将苹果与苹果、橙子与橙子放在一起。LIFT功能负责使用“较低级别”的功能，并将其“升级”为与BIND功能一起使用并可组合。

我希望我做得对，更重要的是，希望这篇文章对单子有一个有效的观点。如果没有别的话，这篇文章有助于激发我学习更多关于单子叶植物的欲望。

monad是用于封装状态变化的对象的东西。在不允许您具有可修改状态的语言（例如，Haskell）中最常遇到这种情况。

例如文件I/O。

您将能够使用文件I/O的monad来将不断变化的状态本质与使用monad的代码隔离开来。Monad内部的代码可以有效地忽略Monad外部世界的变化状态，这使您更容易理解程序的整体效果。

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

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

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

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

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

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

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

这是你要找的视频。

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