就OOP程序员所能理解的（没有任何功能编程背景）而言，什么是monad？
它解决了什么问题，最常用的地方是什么？
使现代化
为了澄清我所寻求的理解，假设您正在将一个具有monad的FP应用程序转换为OOP应用程序。如何将monad的职责移植到OOP应用程序？
当前回答
你最近有一篇演讲《Monadologie——关于类型焦虑的专业帮助》（Christopher League，2010年7月12日），这篇演讲对延续和monad的话题非常有趣。这个（幻灯片）演示的视频实际上可以在vimeo上获得。Monad部分开始于37分钟左右，在这段一小时的视频中，从58张幻灯片中的第42张幻灯片开始。
它被称为“函数式编程的主要设计模式”，但示例中使用的语言是Scala，它既是面向对象的又是函数式的。您可以在Debasish Ghosh（2008年3月27日）的博客文章“Monads-在Scala中抽象计算的另一种方法”中阅读更多关于Monad的内容。
如果类型构造函数M支持以下操作，那么它就是monad：
# the return function
def unit[A] (x: A): M[A]
# called "bind" in Haskell
def flatMap[A,B] (m: M[A]) (f: A => M[B]): M[B]
# Other two can be written in term of the first two:
def map[A,B] (m: M[A]) (f: A => B): M[B] =
flatMap(m){ x => unit(f(x)) }
def andThen[A,B] (ma: M[A]) (mb: M[B]): M[B] =
flatMap(ma){ x => mb }
例如（在Scala中）：
选项是monad
def unit[A] (x: A): Option[A] = Some(x)
def flatMap[A,B](m:Option[A])(f:A =>Option[B]): Option[B] =
m match {
case None => None
case Some(x) => f(x)
}
列表为Monad
def unit[A] (x: A): List[A] = List(x)
def flatMap[A,B](m:List[A])(f:A =>List[B]): List[B] =
m match {
case Nil => Nil
case x::xs => f(x) ::: flatMap(xs)(f)
}
Monad在Scala中非常重要，因为它是为了利用Monad结构而构建的方便语法：
对于Scala的理解：
for {
i <- 1 to 4
j <- 1 to i
k <- 1 to j
} yield i*j*k
由编译器翻译为：
(1 to 4).flatMap { i =>
(1 to i).flatMap { j =>
(1 to j).map { k =>
i*j*k }}}
关键抽象是flatMap，它通过链接绑定计算。flatMap的每次调用都返回相同的数据结构类型（但值不同），作为链中下一个命令的输入。
在上面的代码段中，flatMap将闭包（SomeType）=>List[AanotherType]作为输入，并返回List[Aanother Type]。需要注意的一点是，所有flatMap都采用相同的闭包类型作为输入，并返回与输出相同的类型。
这就是“绑定”计算线程的原因——为了理解，序列中的每一项都必须遵守相同的类型约束。
如果您执行两个操作（可能失败）并将结果传递给第三个，例如：
lookupVenue: String => Option[Venue]
getLoggedInUser: SessionID => Option[User]
reserveTable: (Venue, User) => Option[ConfNo]
但如果不利用Monad，你会得到复杂的OOP代码，比如：
val user = getLoggedInUser(session)
val confirm =
if(!user.isDefined) None
else lookupVenue(name) match {
case None => None
case Some(venue) =>
val confno = reserveTable(venue, user.get)
if(confno.isDefined)
mailTo(confno.get, user.get)
confno
}
而使用Monad，您可以像所有操作一样使用实际类型（地点、用户），并隐藏选项验证内容，这都是因为for语法的平面图：
val confirm = for {
venue <- lookupVenue(name)
user <- getLoggedInUser(session)
confno <- reserveTable(venue, user)
} yield {
mailTo(confno, user)
confno
}
只有当所有三个函数都具有Some[X]时，才会执行屈服部分；任何“无”将直接返回以确认。
So:
Monad允许在函数编程中进行有序计算，这允许我们以一种很好的结构化形式（有点像DSL）对动作序列进行建模。最大的能力来自于将服务于不同目的的monad组合成应用程序中的可扩展抽象的能力。monad对动作的排序和线程化由语言编译器完成，该语言编译器通过闭包的魔力进行转换。
顺便说一句，Monad不是FP中使用的唯一计算模型：
范畴理论提出了许多计算模型。其中计算的Arrow模型莫纳德计算模型计算的应用模型
其他回答
为什么我们需要单子？
我们只想使用函数编程。（毕竟是“功能编程”-FP）。然后，我们遇到了第一个大问题。这是一个程序：f（x）=2*xg（x，y）=x/y我们怎么能说首先要执行什么？我们如何使用不超过个函数来形成一个有序的函数序列（即程序）？解决方案：组合函数。如果你先要g，然后要f，只需写f（g（x，y））。好的，但是。。。更多问题：某些函数可能会失败（即g（2,0），除以0）。我们在FP中没有“例外”。我们如何解决它？解决方案：让我们允许函数返回两种东西：而不是g:Real，Real->Real（函数从两个实数转换为实数），让我们允许g:Real、Real->Real|Nothing（函数从一个实数转换成（实数或零））。但函数应该（更简单地）只返回一件事。解决方案：让我们创建一种要返回的新类型的数据，一种“装箱类型”，它可能包含一个真实的数据，也可能只是一个空数据。因此，我们可以有g：真实，真实->可能真实。好的，但是。。。f（g（x，y））现在发生了什么？f还没有准备好使用“也许真的”。而且，我们不想改变我们可以与g连接的每一个函数，以使用Maybe Real。解决方案：让我们有一个特殊的函数来“连接”/“组合”/“链接”函数。这样，我们就可以在幕后调整一个函数的输出，以支持下一个函数。在我们的例子中：g>>=f（连接/合成g到f）。我们希望>>=获取g的输出，检查它，如果它是Nothing，则不要调用f并返回Nothing；或者相反，提取装箱的实数并用它来馈送f。（此算法只是Maye类型的>>=的实现）。出现了许多其他问题，可以使用相同的模式来解决：1。使用“框”来编码/存储不同的含义/值，并具有像g这样的函数来返回这些“框值”。2.让作曲家/链接器g>>=f帮助将g的输出连接到f的输入，这样我们就不必改变f。使用该技术可以解决的显著问题有：具有函数序列中的每个函数（“程序”）可以共享的全局状态：解StateMonad。我们不喜欢“不纯函数”：对相同输入产生不同输出的函数。因此，让我们标记这些函数，使它们返回一个标记/装箱的值：IOmonad。
完全幸福！！！！
你最近有一篇演讲《Monadologie——关于类型焦虑的专业帮助》（Christopher League，2010年7月12日），这篇演讲对延续和monad的话题非常有趣。这个（幻灯片）演示的视频实际上可以在vimeo上获得。Monad部分开始于37分钟左右，在这段一小时的视频中，从58张幻灯片中的第42张幻灯片开始。
它被称为“函数式编程的主要设计模式”，但示例中使用的语言是Scala，它既是面向对象的又是函数式的。您可以在Debasish Ghosh（2008年3月27日）的博客文章“Monads-在Scala中抽象计算的另一种方法”中阅读更多关于Monad的内容。
如果类型构造函数M支持以下操作，那么它就是monad：
# the return function
def unit[A] (x: A): M[A]
# called "bind" in Haskell
def flatMap[A,B] (m: M[A]) (f: A => M[B]): M[B]
# Other two can be written in term of the first two:
def map[A,B] (m: M[A]) (f: A => B): M[B] =
flatMap(m){ x => unit(f(x)) }
def andThen[A,B] (ma: M[A]) (mb: M[B]): M[B] =
flatMap(ma){ x => mb }
例如（在Scala中）：
选项是monad
def unit[A] (x: A): Option[A] = Some(x)
def flatMap[A,B](m:Option[A])(f:A =>Option[B]): Option[B] =
m match {
case None => None
case Some(x) => f(x)
}
列表为Monad
def unit[A] (x: A): List[A] = List(x)
def flatMap[A,B](m:List[A])(f:A =>List[B]): List[B] =
m match {
case Nil => Nil
case x::xs => f(x) ::: flatMap(xs)(f)
}
Monad在Scala中非常重要，因为它是为了利用Monad结构而构建的方便语法：
对于Scala的理解：
for {
i <- 1 to 4
j <- 1 to i
k <- 1 to j
} yield i*j*k
由编译器翻译为：
(1 to 4).flatMap { i =>
(1 to i).flatMap { j =>
(1 to j).map { k =>
i*j*k }}}
关键抽象是flatMap，它通过链接绑定计算。flatMap的每次调用都返回相同的数据结构类型（但值不同），作为链中下一个命令的输入。
在上面的代码段中，flatMap将闭包（SomeType）=>List[AanotherType]作为输入，并返回List[Aanother Type]。需要注意的一点是，所有flatMap都采用相同的闭包类型作为输入，并返回与输出相同的类型。
这就是“绑定”计算线程的原因——为了理解，序列中的每一项都必须遵守相同的类型约束。
如果您执行两个操作（可能失败）并将结果传递给第三个，例如：
lookupVenue: String => Option[Venue]
getLoggedInUser: SessionID => Option[User]
reserveTable: (Venue, User) => Option[ConfNo]
但如果不利用Monad，你会得到复杂的OOP代码，比如：
val user = getLoggedInUser(session)
val confirm =
if(!user.isDefined) None
else lookupVenue(name) match {
case None => None
case Some(venue) =>
val confno = reserveTable(venue, user.get)
if(confno.isDefined)
mailTo(confno.get, user.get)
confno
}
而使用Monad，您可以像所有操作一样使用实际类型（地点、用户），并隐藏选项验证内容，这都是因为for语法的平面图：
val confirm = for {
venue <- lookupVenue(name)
user <- getLoggedInUser(session)
confno <- reserveTable(venue, user)
} yield {
mailTo(confno, user)
confno
}
只有当所有三个函数都具有Some[X]时，才会执行屈服部分；任何“无”将直接返回以确认。
So:
Monad允许在函数编程中进行有序计算，这允许我们以一种很好的结构化形式（有点像DSL）对动作序列进行建模。最大的能力来自于将服务于不同目的的monad组合成应用程序中的可扩展抽象的能力。monad对动作的排序和线程化由语言编译器完成，该语言编译器通过闭包的魔力进行转换。
顺便说一句，Monad不是FP中使用的唯一计算模型：
范畴理论提出了许多计算模型。其中计算的Arrow模型莫纳德计算模型计算的应用模型
看到我对“什么是monad？”的回答了吗
它从一个激励性的例子开始，通过这个例子，导出一个monad的例子，并正式定义“monad”。
它假设不了解函数式编程，并且使用带有函数（参数）：=表达式语法的伪代码和最简单的表达式。
这个C++程序是伪代码monad的一个实现。（仅供参考：M是类型构造函数，feed是“绑定”操作，wrap是“返回”操作。）
#include <iostream>
#include <string>
template <class A> class M
{
public:
A val;
std::string messages;
};
template <class A, class B>
M<B> feed(M<B> (*f)(A), M<A> x)
{
M<B> m = f(x.val);
m.messages = x.messages + m.messages;
return m;
}
template <class A>
M<A> wrap(A x)
{
M<A> m;
m.val = x;
m.messages = "";
return m;
}
class T {};
class U {};
class V {};
M<U> g(V x)
{
M<U> m;
m.messages = "called g.\n";
return m;
}
M<T> f(U x)
{
M<T> m;
m.messages = "called f.\n";
return m;
}
int main()
{
V x;
M<T> m = feed(f, feed(g, wrap(x)));
std::cout << m.messages;
}
这里有一个简单的Monads解释和Marvel的案例研究。
单子是用于对有效的依赖函数进行排序的抽象。这里的有效意味着它们以F[a]的形式返回一个类型，例如Option[a]，其中Option是F，称为类型构造函数。让我们通过两个简单步骤来了解这一点
下面的函数组合是可传递的。所以从A到C，我可以组成A=>B和B=>C。
A => C = A => B andThen B => C
然而，如果函数返回一个像Option[A]这样的效果类型，即A=>F[B]，则合成不起作用，因为我们需要A=>B，但我们有A=>F[B]。我们需要一个特殊的运算符“bind”，它知道如何融合这些返回F[a]的函数。
A => F[C] = A => F[B] bind B => F[C]
“bind”函数是为特定的F定义的。
对于任何A，也有“return”，类型A=>F[A]，也为特定的F定义。要成为Monad，F必须定义这两个函数。
因此，我们可以从任何纯函数A=>B构造有效函数A=>F[B]，
A => F[B] = A => B andThen return
但给定的F也可以定义自己不透明的“内置”特殊函数，这些函数的类型是用户无法自行定义的（纯语言），例如
“随机”（范围=>随机[Int]）“print”（字符串=>IO[（）]）“尝试…捕捉”等。
可选/可能是最基本的一元类型
单子是关于功能组成的。如果函数f：可选<A>->可选<B>，g：可选<B>->可选<C>，h：可选<C>->可选＜D>。然后你可以创作它们
optional<A> opt;
h(g(f(opt)));
monad类型的好处是，您可以改为组合f:A->可选<B>、g:B->可选<C>、h:C->可选<D>。他们可以这样做，因为monadic接口提供了绑定运算符
auto optional<A>::bind(A->optional<B>)->optional<B>
并且可以写作文
optional<A> opt
opt.bind(f)
.bind(g)
.bind(h)
monads的好处是我们不再需要处理if（！opt）return nullopt的逻辑；在f、g、h中的每一个中，因为该逻辑被移动到绑定运算符中。
ranges/lists/iterables是第二种最基本的monad类型。
范围的一元特征是我们可以变换然后变平，即从一个整数范围内编码的表示开始[36，98]
我们可以转换为[[m'，'a'，'c'，'h'，'i'，'n'，'e'，'']，['l'，''，'r'，'n'，'i'，'n'，'g'，'.']]
然后压平[am'，'a'，'c'，'h'，'i'，'n'，'e'，'l'，''e'
而不是编写此代码
vector<string> lookup_table;
auto stringify(vector<unsigned> rng) -> vector<char>
{
vector<char> result;
for(unsigned key : rng)
for(char ch : lookup_table[key])
result.push_back(ch);
result.push_back(' ')
result.push_back('.')
return result
}
我们可以写这个
auto f(unsigned key) -> vector<char>
{
vector<char> result;
for(ch : lookup_table[key])
result.push_back(ch);
return result
}
auto stringify(vector<unsigned> rng) -> vector<char>
{
return rng.bind(f);
}
monad将for循环（无符号键：rng）向上推到绑定函数中，从而允许理论上更容易推理的代码。毕达哥拉斯三元组可以在范围-v3中使用嵌套绑定生成（而不是我们看到的可选的链式绑定）
auto triples =
for_each(ints(1), [](int z) {
return for_each(ints(1, z), [=](int x) {
return for_each(ints(x, z), [=](int y) {
return yield_if(x*x + y*y == z*z, std::make_tuple(x, y, z));
});
});
});
