Monoid似乎可以确保在Monoid和受支持的类型上定义的所有操作始终返回Monoid内部的受支持类型。任何数字+任何数字=一个数字，没有错误。

而除法接受两个分数，并返回一个分数，该分数在haskell somewhy中将除以零定义为无穷大（恰好是分数somewhy）。。。

在任何情况下，Monads似乎只是一种确保您的操作链以可预测的方式运行的方法，而一个声称为Num->Num的函数，由另一个用x调用的Num->Num的函数组成，并不意味着发射导弹。

另一方面，如果我们有一个功能可以发射导弹，我们可以将它与其他功能组合起来，也可以发射导弹。

在Haskell中，main的类型是IO（）或IO[（）]，这种区分很奇怪，我不会讨论它，但我认为会发生以下情况：

如果我有main，我希望它做一系列动作，我运行程序的原因是产生一个效果——通常是通过IO。因此，我可以将IO操作串联在一起，以便——做IO，而不是其他。

如果我尝试做一些不“返回IO”的事情，程序会抱怨链不流动，或者基本上“这与我们正在尝试做的事情有什么关系——IO动作”，这似乎迫使程序员保持思路，不偏离并思考发射导弹，同时创建排序算法——不流动。

基本上，Monads似乎是编译器的一个提示，“嘿，你知道这个函数在这里返回一个数字，它实际上并不总是有效的，它有时会产生一个number，有时什么都没有，请记住这一点”。知道了这一点，如果你试图断言一个单元动作，单元动作可能会作为一个编译时异常，说“嘿，这实际上不是一个数字，这可能是一个数字。但你不能假设这一点。做一些事情以确保流是可接受的。”这在一定程度上防止了不可预测的程序行为。

似乎monad不是关于纯粹性，也不是关于控制，而是关于维护一个类别的身份，在这个类别上，所有行为都是可预测和定义的，或者不编译。当你被要求做某事时，你不能什么都不做，如果你被要求什么都不干（可见），你也不能做。

我能想到的Monads的最大原因是——看看程序/OOP代码，你会发现你不知道程序从哪里开始，也不知道程序的结束，你看到的只是大量的跳跃和大量的数学、魔法和导弹。您将无法维护它，如果可以的话，您将花费大量的时间来思考整个程序，然后才能理解其中的任何部分，因为在这种情况下，模块化是基于代码的相互依赖的“部分”，其中代码被优化为尽可能相关，以保证效率/相互关系。单子是非常具体的，并且通过定义得到了很好的定义，并确保程序流程可以进行分析，并隔离难以分析的部分——因为它们本身就是单子。monad似乎是一个“可理解的单元，它在完全理解时是可预测的”——如果你理解“可能”monad，那么它除了“可能”之外就没有可能做任何事情，这看起来微不足道，但在大多数非monad代码中，一个简单的函数“helloworld”可以发射导弹，什么都不做，或者摧毁宇宙，甚至扭曲时间——我们不知道也不能保证它是什么样子。一个单子保证它就是什么样子。这是非常强大的。

“现实世界”中的所有事物似乎都是单子，因为它受到防止混淆的明确可观察规律的约束。这并不意味着我们必须模仿这个对象的所有操作来创建类，相反，我们可以简单地说“一个正方形就是一个正方形”，只不过是一个正方形，甚至不是矩形或圆形，和“一个正方形的面积是它现有维度的长度乘以它自身的面积。无论你有什么正方形，如果它是2D空间中的正方形，它的面积绝对不能是任何东西，只有它的长度平方，这几乎是微不足道的。这是非常强大的，因为我们不需要断言我们的世界是这样的，我们只需要使用现实的含义来预测它。”防止我们的节目偏离轨道。

我几乎可以肯定是错的，但我认为这可以帮助一些人，所以希望它能帮助一些人。

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

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

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

[免责声明：我仍在努力完全了解monads。以下是我目前所了解的情况。如果这是错误的，希望有有知识的人会在地毯上给我打电话。]

Arnar写道：

Monads只是一种包装东西的方法，它提供了对包装好的东西进行操作而不展开的方法。

正是这样。想法是这样的：

你需要一些价值，并用一些附加信息来包装它。就像值是某种类型的（例如整数或字符串）一样，附加信息也是某种类型的。例如，该额外信息可能是“可能”或“IO”。然后，您有一些运算符，允许您在携带附加信息的同时对打包的数据进行操作。这些运算符使用附加信息来决定如何更改包装值上的操作行为。例如，Maybe Int可以是Just Int或Nothing。现在，如果您将Maybe Int添加到Maybe Int，则运算符将检查它们是否都是内部的Just Int，如果是，则将展开Int，将其传递给加法运算符，将生成的Int重新包装为新的Just Int（这是有效的Maybe Int），从而返回Maybe Int。但如果其中一个是内部的Nothing，则该运算符将立即返回Nothing，这也是一个有效的Maybe Int。这样，你可以假装Maybe Ints只是正常的数字，并对它们进行常规运算。如果你得到了一个Nothing，你的方程仍然会产生正确的结果——而不必到处乱检查Nothing。

但这个例子正是Maybe所发生的事情。如果额外的信息是IO，那么将调用为IO定义的特殊运算符，并且在执行添加之前，它可以执行完全不同的操作。（好吧，将两个IO Int加在一起可能是荒谬的——我还不确定。）

基本上，“monad”大致意思是“模式”。但是，您现在有了一种语言构造（语法和所有），可以将新模式声明为程序中的东西，而不是一本充满了非正式解释和专门命名的模式的书。（这里的不精确之处在于所有模式都必须遵循特定的形式，因此monad不像模式那样通用。但我认为这是大多数人都知道和理解的最接近的术语。）

这就是为什么人们觉得单子如此令人困惑：因为它们是一个通用的概念。问是什么使某物成为monad与问是什么让某物成为模式类似。

但是想想在语言中对模式的概念提供语法支持的含义：你不必阅读“四人帮”一书，记住特定模式的构造，只需编写一次代码，以不可知的通用方式实现这个模式，然后就完成了！然后，您可以重用此模式，如Visitor或Strategy或Façade等，只需用它装饰代码中的操作，而无需反复重新实现它！

所以，这就是为什么理解monad的人会发现它们如此有用的原因：这并不是知识势利者以理解为荣的象牙塔概念（好吧，当然也是如此，teehee），而是实际上让代码更简单。

遵循您简短、简洁、实用的指示：

理解monad最简单的方法是在上下文中应用/组合函数。假设你有两个计算，它们都可以看作是两个数学函数f和g。

f取一个String并生成另一个String（取前两个字母）g获取一个String并生成另一个String（大写转换）

因此，在任何语言中，“取前两个字母并将其转换为大写”的转换都会写成g（f（“某个字符串”））。因此，在纯完美函数的世界中，合成只是：先做一件事，然后再做另一件事。

但假设我们生活在一个功能可能失败的世界中。例如：输入字符串可能有一个字符长，因此f将失败。所以在这种情况下

f获取一个String并生成一个String或Nothing。g仅在f未失败时生成字符串。否则，将不生成任何内容

所以现在，g（f（“somestring”））需要一些额外的检查：“计算f，如果它失败，那么g应该返回Nothing，否则计算g”

此思想可应用于任何参数化类型，如下所示：

让Context[Sometype]是Context中Sometype的计算。考虑功能

f： ：AnyType->上下文[Sometype]g： ：某些类型->上下文[AnyOtherType]

合成g（f（））应该读作“compute f。在这个上下文中，做一些额外的计算，然后计算g，如果它在上下文中有意义”

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)

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