如果你要求对如此抽象的东西做出简洁、实用的解释，那么你只能希望得到一个抽象的答案：

a -> b

是表示从as到bs的计算的一种方式。您可以将计算链接起来，也可以将它们组合在一起：

(b -> c) -> (a -> b) -> (a -> c)

更复杂的计算需要更复杂的类型，例如：

a -> f b

是从as到bs到fs的计算类型。您还可以编写它们：

(b -> f c) -> (a -> f b) -> (a -> f c)

事实证明，这种模式无处不在，并且与上面的第一个组合具有相同的财产（结合性、右-和左-同一性）。

人们必须给这个模式起一个名字，但如果知道第一个组合被正式描述为半群体，这会有帮助吗？

“单子和圆括号一样有趣和重要”（奥列格·基斯廖夫）

经过努力，我想我终于明白了单子。在重新阅读了我自己对绝大多数投票结果的冗长批评之后，我将给出这个解释。

要理解单子，需要回答三个问题：

你为什么需要蒙纳德？什么是单子？如何实现monad？

正如我在最初的评论中所指出的，有太多的monad解释被第3个问题所困扰，没有，也没有充分地涵盖第2个问题或第1个问题。

你为什么需要蒙纳德？

Haskell等纯函数式语言与C或Java等命令式语言的不同之处在于，纯函数式程序不一定按特定顺序执行，一步一步执行。Haskell程序更类似于一个数学函数，在该函数中，您可以以任意数量的潜在阶数求解“方程”。这带来了许多好处，其中之一是它消除了某些类型的错误的可能性，特别是那些与“状态”相关的错误。

然而，使用这种编程风格，有些问题不是很容易解决的。有些事情，比如控制台编程和文件i/o，需要按照特定的顺序进行，或者需要维护状态。处理这个问题的一种方法是创建一种表示计算状态的对象，以及一系列将状态对象作为输入并返回新修改的状态对象的函数。

因此，让我们创建一个假设的“状态”值，它表示控制台屏幕的状态。这个值是如何构造的并不重要，但假设它是一个字节长度的ascii字符数组，表示屏幕上当前可见的内容，以及一个表示用户输入的最后一行伪代码的数组。我们已经定义了一些接受控制台状态、修改它并返回新控制台状态的函数。

consolestate MyConsole = new consolestate;

因此，要进行控制台编程，但以纯函数的方式，您需要在彼此之间嵌套许多函数调用。

consolestate FinalConsole = print(input(print(myconsole, "Hello, what's your name?")),"hello, %inputbuffer%!");

以这种方式编程保持了“纯”的功能风格，同时强制对控制台的更改按特定顺序进行。但是，我们可能希望像上面的示例一样，一次只执行几个操作。以这种方式嵌套函数将开始变得笨拙。我们想要的是基本上与上面相同的代码，但编写得更像这样：

consolestate FinalConsole = myconsole:
                            print("Hello, what's your name?"):
                            input():
                            print("hello, %inputbuffer%!");

这确实是一种更方便的写法。但我们如何做到这一点呢？

什么是单子？

一旦你定义了一个类型（比如consoleestate），以及一系列专门为该类型操作而设计的函数，你就可以通过定义一个操作符（比如：（bind））将这些东西的整个包变成一个“monad”，该操作符会自动将返回值输入到左边的函数参数中，转换为与特定类型的绑定运算符一起工作的函数。

如何实现monad？

看到其他答案，似乎可以很自由地跳到细节中。

解释

当用C#/Java术语解释时，这很简单：

monad是一个接受参数并返回特殊类型的函数。这个monad返回的特殊类型也称为monad。（monad是#1和#2的组合）有一些语法糖可以使调用此函数和类型转换更容易。

实例

monad有助于使函数式程序员的生活更轻松。典型示例：Maye monad接受两个参数，一个值和一个函数。如果传递的值为null，则返回null。否则它将计算函数。如果我们需要一个特殊的返回类型，我们也可以调用这个返回类型Maybe。一个非常粗糙的实现如下所示：

object Maybe(object value, Func<object,object> function)
{
    if(value==null)
        return null;

    return function(value);
}

这在C#中是非常无用的，因为这种语言缺乏使monad有用所需的语法糖。但是monad允许您用函数式编程语言编写更简洁的代码。

通常程序员在链中调用monad，如下所示：

var x = Maybe(x, x2 => Maybe(y, y2 => Add(x2, y2)));

在本例中，只有当x和y都为非null时，才会调用Add方法，否则将返回null。

答复

回答最初的问题：monad是一个函数和一个类型。就像一个特殊接口的实现。

在几年前回答了这个问题之后，我相信我可以通过。。。

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。

这个答案从一个激励性的例子开始，通过这个例子，得出一个单子的例子，并正式定义了“单子”。

考虑伪代码中的这三个函数：

f(<x, messages>) := <x, messages "called f. ">
g(<x, messages>) := <x, messages "called g. ">
wrap(x)          := <x, "">

f采用<x，messages>形式的有序对，并返回一个有序对。它保持第一项不变，并在第二项后面附加“called f.”。与g相同。

您可以组合这些函数并获得原始值，以及显示函数调用顺序的字符串：

  f(g(wrap(x)))
= f(g(<x, "">))
= f(<x, "called g. ">)
= <x, "called g. called f. ">

您不喜欢f和g负责将自己的日志消息附加到先前的日志信息。（为了论证起见，想象一下，f和g必须对这对中的第二项执行复杂的逻辑，而不是附加字符串。在两个或多个不同的函数中重复这种复杂的逻辑会很痛苦。）

您更喜欢编写更简单的函数：

f(x)    := <x, "called f. ">
g(x)    := <x, "called g. ">
wrap(x) := <x, "">

但看看当你编写它们时会发生什么：

  f(g(wrap(x)))
= f(g(<x, "">))
= f(<<x, "">, "called g. ">)
= <<<x, "">, "called g. ">, "called f. ">

问题是，将一对传递到函数中并不能得到所需的结果。但如果你可以将一对输入到函数中呢：

  feed(f, feed(g, wrap(x)))
= feed(f, feed(g, <x, "">))
= feed(f, <x, "called g. ">)
= <x, "called g. called f. ">

将feed（f，m）读为“feed m into f”。要将一对＜x，messages＞输入函数f，需要将x传递给f，从f中获取＜y，messages〕，并返回＜y，message message＞。

feed(f, <x, messages>) := let <y, message> = f(x)
                          in  <y, messages message>

请注意，当您对函数执行三项操作时会发生什么：

首先：如果包装一个值，然后将结果对送入函数：

  feed(f, wrap(x))
= feed(f, <x, "">)
= let <y, message> = f(x)
  in  <y, "" message>
= let <y, message> = <x, "called f. ">
  in  <y, "" message>
= <x, "" "called f. ">
= <x, "called f. ">
= f(x)

这与将值传递给函数相同。

第二：如果你把一对放进包装里：

  feed(wrap, <x, messages>)
= let <y, message> = wrap(x)
  in  <y, messages message>
= let <y, message> = <x, "">
  in  <y, messages message>
= <x, messages "">
= <x, messages>

这不会改变这对。

第三：如果定义了一个函数，该函数将x和g（x）输入f：

h(x) := feed(f, g(x))

并向其中输入一对：

  feed(h, <x, messages>)
= let <y, message> = h(x)
  in  <y, messages message>
= let <y, message> = feed(f, g(x))
  in  <y, messages message>
= let <y, message> = feed(f, <x, "called g. ">)
  in  <y, messages message>
= let <y, message> = let <z, msg> = f(x)
                     in  <z, "called g. " msg>
  in <y, messages message>
= let <y, message> = let <z, msg> = <x, "called f. ">
                     in  <z, "called g. " msg>
  in <y, messages message>
= let <y, message> = <x, "called g. " "called f. ">
  in <y, messages message>
= <x, messages "called g. " "called f. ">
= feed(f, <x, messages "called g. ">)
= feed(f, feed(g, <x, messages>))

这与将对输入g和将所得对输入f相同。

你有大部分的单子。现在您只需要了解程序中的数据类型。

<x，“称为f”>是什么类型的值？这取决于x是什么类型的值。如果x是t类型的，那么你的对就是“t和字符串对”类型的值了。称之为M型。

M是一个类型构造器：M本身并不表示一个类型，但一旦你用一个类型填空，M _就表示一个。M int是一对int和一个字符串。M字符串是一对字符串和一个字符串。等

恭喜你，你已经创建了monad！

形式上，你的monad是元组＜M，feed，wrap＞。

monad是一个元组＜M，feed，wrap＞，其中：

M是类型构造函数。feed接受一个（函数接受一个t并返回一个M u）和一个M t并返回M u。wrap接受一个v并返回一个M v。

t、 u和v是可以相同也可以不同的任意三种类型。单子满足您为特定单子证明的三个财产：

将包裹的t送入函数与将未包裹的t传入函数相同。形式上：饲料（f，包装（x））=f（x）将M t喂入包装物对M t没有任何影响。形式上：进给（包裹，m）=m将一个M t（称为M）输入一个函数将t传递到g从g得到一个M u（称为n）将n输入f与m进g从g得到n将n输入f形式上：饲料（h，m）=饲料（f，饲料（g，m）），其中h（x）：=饲料（f，g（x））

通常，feed称为bind（在Haskell中为AKA>>=），wrap称为return。

你应该首先了解函子是什么。在此之前，先了解高阶函数。

高阶函数只是一个以函数为自变量的函数。

函子是任何类型构造T，其中存在一个高阶函数，称之为map，它将类型为A->b的函数（给定任意两个类型A和b）转换为函数Ta->Tb。该map函数还必须遵守恒等式和复合法则，以便以下表达式对所有p和q返回true（Haskell表示法）：

map id = id
map (p . q) = map p . map q

例如，名为List的类型构造函数是一个函子，如果它配备了一个类型为（a->b）->Lista->Listb的函数，该函数遵守上述定律。唯一实际的实施是显而易见的。生成的Lista->Listb函数在给定列表上迭代，为每个元素调用（a->b）函数，并返回结果列表。

monad本质上只是一个函子T，它有两个额外的方法，类型为T（T A）->T A的join和类型为A->T A的unit（有时称为return、fork或pure）。对于Haskell中的列表：

join :: [[a]] -> [a]
pure :: a -> [a]

为什么有用？因为例如，您可以使用返回列表的函数映射列表。Join获取生成的列表列表并将它们连接起来。列表是monad，因为这是可能的。

您可以编写一个函数，先映射，然后连接。此函数称为bind或flatMap，或（>>=）或（=<<）。这通常是Haskell中给出monad实例的方式。

monad必须满足某些定律，即联接必须是关联的。这意味着，如果您的值x类型为[[a]]]，那么join（join x）应该等于join（map joinx）。纯必须是联接的标识，这样联接（纯x）==x。