在最近简要回顾了Haskell之后，对于monad本质上是什么，有什么简单、简洁、实用的解释？
我发现，我遇到的大多数解释都很难理解，而且缺乏实际细节。
当前回答
http://mikehadlow.blogspot.com/2011/02/monads-in-c-8-video-of-my-ddd9-monad.html
这是你要找的视频。
用C#演示组合和对齐类型的问题，然后用C#正确实现它们。最后，他展示了F#和Haskell中相同的C#代码的外观。
其他回答
公主对F#计算表达式的解释帮助了我，尽管我仍然不能说我真的理解了。
编辑：这个系列-用javascript解释monad-对我来说是一个“打破平衡”的系列。
http://blog.jcoglan.com/2011/03/05/translation-from-haskell-to-javascript-of-selected-portions-of-the-best-introduction-to-monads-ive-ever-read/http://blog.jcoglan.com/2011/03/06/monad-syntax-for-javascript/http://blog.jcoglan.com/2011/03/11/promises-are-the-monad-of-asynchronous-programming/
我认为理解单子是一件让你毛骨悚然的事。从这个意义上说，尽可能多地阅读“教程”是一个好主意，但通常奇怪的东西（不熟悉的语言或语法）会让你的大脑无法专注于基本内容。
有些事情我很难理解：
基于规则的解释对我来说从未奏效，因为大多数实际示例实际上需要的不仅仅是返回/绑定。此外，称之为规则也无济于事。这更像是“有些东西有共同点，我们把它们称为‘单子’，把共同点称为‘规则’”。Return（a->M<a>）和Bind（M<a>->（a->M<b>）->M<b>）很好，但我永远无法理解Bind如何从M<a>中提取a，以便将其传递给a->M<b>。我不认为我在任何地方读过（也许这对其他人来说都很明显），Return（M<a>->a）的反面必须存在于monad内部，它只是不需要暴露。
另一种尝试是解释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博客文章，但我认为这对识别野外现存的monad很有用。
单子是分形
上面是一个叫做Sierpinski三角形的分形，这是我唯一记得画的分形。分形是与上述三角形相似的自相似结构，其中部分与整体相似（在这种情况下，正好是母三角形比例的一半）。单子是分形。给定一个一元数据结构，它的值可以组合成数据结构的另一个值。这就是为什么它对编程有用，这也是为什么它在许多情况下都会出现。
monad是一种将共享共同上下文的计算组合在一起的方法。这就像建立一个管道网络。当构建网络时，没有数据流过它。但是当我用“bind”和“return”将所有位拼接在一起后，我调用类似runMyMonad monad数据的东西，数据流过管道。
第一：如果你不是数学家，monad这个词有点空洞。另一个术语是计算构建器，它更能描述它们的实际用途。
它们是链接操作的模式。它看起来有点像面向对象语言中的方法链接，但机制略有不同。
该模式主要用于函数式语言（特别是Haskell，它普遍使用monad），但也可以用于支持高阶函数的任何语言（即可以将其他函数作为参数的函数）。
JavaScript中的数组支持该模式，因此让我们将其作为第一个示例。
模式的要点是我们有一个类型（在本例中为Array），它有一个以函数作为参数的方法。提供的操作必须返回相同类型的实例（即返回数组）。
首先是一个不使用monad模式的方法链接示例：
[1,2,3].map(x => x + 1)
结果是[2,3,4]。代码不符合monad模式，因为我们作为参数提供的函数返回的是数字，而不是数组。monad形式的相同逻辑是：
[1,2,3].flatMap(x => [x + 1])
这里我们提供了一个返回Array的操作，所以现在它符合模式。flatMap方法为数组中的每个元素执行提供的函数。它期望每个调用都有一个数组作为结果（而不是单个值），但将得到的数组集合并为一个数组。所以最终的结果是相同的，数组[2,3,4]。
（提供给map或flatMap等方法的函数参数在JavaScript中通常称为“回调”。我将其称为“操作”，因为它更通用。）
如果我们连锁多个操作（以传统方式）：
[1,2,3].map(a => a + 1).filter(b => b != 3)
数组中的结果[2,4]
monad形式的相同链接：
[1,2,3].flatMap(a => [a + 1]).flatMap(b => b != 3 ? [b] : [])
产生相同的结果，即数组[2,4]。
您将立即注意到monad格式比非monad格式更难看！这正好表明单子不一定“好”。它们是一种有时有益有时不有益的模式。
请注意，monad模式可以以不同的方式组合：
[1,2,3].flatMap(a => [a + 1].flatMap(b => b != 3 ? [b] : []))
这里的绑定是嵌套的，而不是链式的，但结果是一样的。这是单子的一个重要属性，我们稍后会看到。这意味着组合的两个操作可以被视为单个操作。
该操作允许返回具有不同元素类型的数组，例如，将数字数组转换为字符串数组或其他东西；只要它仍然是一个数组。
这可以使用Typescript表示法更正式地描述。数组的类型为array＜T＞，其中T是数组中元素的类型。flatMap（）方法接受类型为T=>Array<U>的函数参数，并返回一个Array<U>。
一般来说，monad是任何类型的Foo＜Bar＞，它有一个“bind”方法，该方法接受类型为Bar＝＞Foo＜Baz＞的函数参数，并返回一个Foo＜Baz＞。
这回答了单子是什么。这个答案的其余部分将试图通过示例来解释为什么monads在Haskell这样的语言中是一种有用的模式，而Haskell对monads有很好的支持。
Haskell和Do表示法
要将map/filter示例直接转换为Haskell，我们将flatMap替换为>>=运算符：
[1,2,3] >>= \a -> [a+1] >>= \b -> if b == 3 then [] else [b]
>>=运算符是Haskell中的绑定函数。当操作数是一个列表时，它与JavaScript中的flatMap相同，但对于其他类型，它被重载了不同的含义。
但是Haskell还为monad表达式提供了专用语法do块，它完全隐藏了绑定运算符：
do a <- [1,2,3]
b <- [a+1]
if b == 3 then [] else [b]
这将隐藏“管道”，并让您专注于在每个步骤中应用的实际操作。
在do块中，每一行都是一个操作。约束仍然认为块中的所有操作都必须返回相同的类型。因为第一个表达式是一个列表，所以其他操作也必须返回一个列表。
向后箭头<-看起来像赋值，但请注意，这是绑定中传递的参数。因此，当右侧的表达式是整数列表时，左侧的变量将是一个整数，但将对列表中的每个整数执行。
示例：安全导航（Maybe类型）
关于列表，让我们来看看monad模式如何对其他类型有用。
某些函数可能不总是返回有效值。在Haskell中，这由Maybe类型表示，该类型是Just value或Nothing选项。
总是返回有效值的链接操作当然很简单：
streetName = getStreetName (getAddress (getUser 17))
但如果任何函数都可以返回Nothing呢？我们需要单独检查每个结果，如果不是Nothing，则只将值传递给下一个函数：
case getUser 17 of
Nothing -> Nothing
Just user ->
case getAddress user of
Nothing -> Nothing
Just address ->
getStreetName address
很多重复检查！想象一下如果链条更长。Haskell用Maybe的monad模式解决了这个问题：
do
user <- getUser 17
addr <- getAddress user
getStreetName addr
这个do块调用Maybe类型的绑定函数（因为第一个表达式的结果是Maybe）。绑定函数仅在值为Just值时执行以下操作，否则只传递Nothing。
这里使用monad模式来避免重复代码。这与其他一些语言使用宏来简化语法的方式类似，尽管宏以非常不同的方式实现了相同的目标。
请注意，Haskell中monad模式和monad友好语法的结合导致了代码更干净。在JavaScript这样的语言中，如果没有对monad的任何特殊语法支持，我怀疑monad模式是否能够在这种情况下简化代码。
可变状态
Haskell不支持可变状态。所有变量都是常量，所有值都是不可变的。但State类型可用于模拟具有可变状态的编程：
add2 :: State Integer Integer
add2 = do
-- add 1 to state
x <- get
put (x + 1)
-- increment in another way
modify (+1)
-- return state
get
evalState add2 7
=> 9
add2函数构建一个monad链，然后以7作为初始状态对其求值。
显然，这在Haskell中才有意义。其他语言支持开箱即用的可变状态。Haskell通常在语言特性上是“选择加入”的——您可以在需要时启用可变状态，并且类型系统确保效果是显式的。IO是这方面的另一个例子。
IO
IO类型用于链接和执行“不纯”函数。
与任何其他实用语言一样，Haskell有一系列与外界接口的内置函数：putStrLine、readLine等。这些函数被称为“不纯”，因为它们要么会产生副作用，要么会产生不确定性的结果。即使是像获取时间这样简单的事情也被认为是不纯洁的，因为结果是不确定的——用相同的参数调用两次可能会返回不同的值。
纯函数是确定性的——它的结果完全取决于传递的参数，除了返回值之外，它对环境没有任何副作用。
Haskell大力鼓励使用纯函数——这是该语言的一个主要卖点。不幸的是，对于纯粹主义者来说，你需要一些不纯的函数来做任何有用的事情。Haskell折衷方案是将纯函数和不纯函数彻底分开，并保证纯函数无法直接或间接执行不纯函数。
这是通过给所有不纯函数赋予IO类型来保证的。Haskell程序的入口点是具有IO类型的主函数，因此我们可以在顶层执行不纯的函数。
但是该语言如何防止纯函数执行不纯函数？这是因为Haskell的懒惰本性。只有当某个函数的输出被其他函数消耗时，才执行该函数。但除了将IO值分配给main之外，没有办法使用它。因此，如果一个函数想要执行一个不纯的函数，它必须连接到main并具有IO类型。
对IO操作使用monad链接还可以确保它们以线性和可预测的顺序执行，就像命令式语言中的语句一样。
这让我们看到大多数人会用Haskell编写的第一个程序：
main :: IO ()
main = do
putStrLn ”Hello World”
当只有一个操作，因此没有什么要绑定时，do关键字是多余的，但为了保持一致性，我还是保留了它。
（）类型表示“无效”。这种特殊的返回类型仅适用于因其副作用而调用的IO函数。
更长的示例：
main = do
putStrLn "What is your name?"
name <- getLine
putStrLn "hello" ++ name
这构建了一个IO操作链，因为它们被分配给主功能，所以它们被执行。
将IO与Maybe进行比较表明了monad模式的多功能性。对于Maybe，该模式用于通过将条件逻辑移动到绑定函数来避免重复代码。对于IO，该模式用于确保IO类型的所有操作都是有序的，并且IO操作不会“泄漏”到纯函数。
总结
在我的主观看法中，monad模式只有在对该模式有一些内置支持的语言中才真正有价值。否则，它只会导致过于复杂的代码。但是Haskell（和其他一些语言）有一些内置支持，隐藏了繁琐的部分，然后该模式可以用于各种有用的事情。喜欢：
避免重复代码（可能）为程序的分隔区域添加可变状态或异常等语言特性。将讨厌的东西与美好的东西隔离开来（IO）嵌入式域特定语言（解析器）将GOTO添加到语言中。
