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是一种函数组合技术，它使用组合函数bind将某些输入场景的处理具体化，以在组合过程中预处理输入。

在正常合成中，函数compose（>>）用于按顺序将合成的函数应用于其前身的结果。重要的是，所组成的函数需要处理其输入的所有场景。

（x->y）>>（y->z）

这种设计可以通过重组输入来改进，以便更容易地询问相关状态。因此，如果y包含有效性的概念，则值可以变成Mb，例如（is_OK，b），而不是简单的y。

例如，当输入仅可能是一个数字时，而不是返回一个可以尽职尽责地包含数字或不包含数字的字符串，您可以将类型重新构造为bool，以指示元组中存在有效数字和数字，例如bool*float。组合函数现在不再需要解析输入字符串来确定数字是否存在，而只需要检查元组的布尔部分。

（Ma->Mb）>>（Mb->Mc）

在这里，合成与合成一起自然发生，因此每个函数必须单独处理其输入的所有场景，尽管现在这样做要容易得多。

然而，如果我们能够将审讯的工作外化，以应对那些处理场景是常规的情况，那又会怎样呢。例如，如果我们的程序在输入不正常时什么都不做，比如is_OK为false时。如果做到了这一点，那么组合函数就不需要自己处理该场景，从而大大简化了代码并实现了另一个级别的重用。

为了实现这种外部化，我们可以使用bind（>>=）函数来执行组合而不是组合。因此，不是简单地将值从一个函数的输出传递到另一个函数输入，而是检查Ma的M部分，并决定是否以及如何将组合函数应用于a。当然，函数绑定将专门为我们的特定M定义，以便能够检查其结构并执行我们想要的任何类型的应用。尽管如此，a可以是任何东西，因为bind仅在确定应用程序需要时将未检查的a传递给组合函数。此外，组合函数本身也不再需要处理输入结构的M部分，从而简化了它们。因此

（a->Mb）>>=（b->Mc）或更简洁地Mb>>=

简言之，一旦输入被设计为充分暴露某些输入场景，monad就外部化了，从而提供了关于处理这些输入场景的标准行为。这种设计是一种外壳和内容模型，其中外壳包含与组合函数的应用程序相关的数据，并由绑定函数查询，并且仅对绑定函数可用。

因此，单子是三件事：

M外壳，用于保存monad相关信息，实现的绑定函数，用于在将组合函数应用于其在外壳中找到的内容值时使用该外壳信息，以及形式为a->Mb的可组合函数，生成包含单元管理数据的结果。

一般来说，函数的输入比其输出更具限制性，其中可能包括错误条件等；因此，Mb结果结构通常非常有用。例如，当除数为0时，除法运算符不返回数字。

此外，monad可以包括将值a包装成monadic类型Ma的包装函数，以及将一般函数a->b包装成monodic函数a->Mb的包装函数。当然，像bind一样，这样的包装函数是M特有的。例如：

let return a = [a]
let lift f a = return (f a)

绑定函数的设计假定了不可变的数据结构和纯函数，其他事情变得复杂，无法保证。因此，有一元定律：

鉴于

M_ 
return = (a -> Ma)
f = (a -> Mb)
g = (b -> Mc)

然后

Left Identity  : (return a) >>= f === f a
Right Identity : Ma >>= return    === Ma
Associative    : Ma >>= (f >>= g) === Ma >>= ((fun x -> f x) >>= g)

关联性意味着无论何时应用绑定，绑定都会保留求值顺序。也就是说，在上述关联性的定义中，对f和g的括号化绑定的强制早期评估只会导致期望Ma的函数完成绑定。因此，必须先确定Ma的值，然后才能将其值应用于f，进而将结果应用于g。

另一种尝试是解释monad，只使用Python列表和map函数。我完全接受这不是一个完整的解释，但我希望它能触及核心概念。

我从Monads上的funfunfunction视频和Learn You A Haskell章节“为了几个Monads更多”中得到了这一点的基础。我强烈推荐观看funfunfunction视频。

最简单的是，Monad是具有map和flatMap函数（在Haskell中绑定）的对象。有一些额外的必需财产，但这些是核心属性。

flatMap“展平”map的输出，对于列表，这只是连接列表的值，例如。

concat([[1], [4], [9]]) = [1, 4, 9]

因此，在Python中，我们基本上可以通过以下两个函数实现Monad：

def flatMap(func, lst):
    return concat(map(func, lst))

def concat(lst):
    return sum(lst, [])

func是任何接受值并返回列表的函数。

lambda x: [x*x]

解释

为了清楚起见，我通过一个简单的函数在Python中创建了concat函数，该函数将列表相加，即[]+[1]+[4]+[9]=[1，4，9]（Haskell有一个原生的concat方法）。

我假设你知道地图功能是什么，例如：

>>> list(map(lambda x: [x*x], [1,2,3]))
[[1], [4], [9]]

展平是Monad的关键概念，对于每个作为Monad的对象，这种展平允许您获得Monad中包裹的值。

现在我们可以呼叫：

>>> flatMap(lambda x: [x*x], [1,2,3])
[1, 4, 9]

这个lambda取一个值x并将其放入一个列表中。monad适用于从值到monad类型的任何函数，所以在本例中是列表。

这是你的monad定义。

我认为为什么它们有用的问题已经在其他问题中得到了回答。

更多说明

其他不是列表的例子有JavaScript Promise，它有then方法，JavaScript Streams有flatMap方法。

因此Promise和Streams使用了一个稍微不同的函数，它将Stream或Promise展平，并从内部返回值。

Haskell列表monad具有以下定义：

instance Monad [] where  
    return x = [x]  
    xs >>= f = concat (map f xs)  
    fail _ = [] 

即有三个函数return（不要与大多数其他语言中的return混淆）、>>=（flatMap）和fail。

希望您能看到以下两者之间的相似之处：

xs >>= f = concat (map f xs)

and:

def flatMap(f, xs):
    return concat(map(f, xs))

monad是一个容器，但用于数据。一个特殊的容器。

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

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

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

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

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

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

实际上，monad是函数组合运算符的一种自定义实现，它考虑了副作用以及不兼容的输入和返回值（用于链接）。