我想说，与monads最接近的OO类比是“命令模式”。

在命令模式中，将普通语句或表达式包装在命令对象中。命令对象公开执行包装语句的执行方法。所以，语句被转换为可以随意传递和执行的第一类对象。可以组合命令，以便通过链接和嵌套命令对象来创建程序对象。

命令由单独的对象调用程序执行。使用命令模式（而不仅仅是执行一系列普通语句）的好处是，不同的调用程序可以将不同的逻辑应用于如何执行命令。

命令模式可用于添加（或删除）宿主语言不支持的语言功能。例如，在没有异常的假设OO语言中，可以通过向命令公开“try”和“throw”方法来添加异常语义。当命令调用throw时，调用程序会回溯到命令列表（或树），直到最后一次“try”调用。相反，您可以通过捕获每个单独命令抛出的所有异常，并将它们转换为错误代码，然后传递给下一个命令，从而从语言中删除异常语义（如果您认为异常是坏的）。

甚至更花哨的执行语义（如事务、非确定性执行或延续）也可以用本机不支持的语言实现。如果你仔细想想，这是一个非常强大的模式。

实际上，命令模式并没有像这样作为通用语言特性使用。将每个语句转换为单独的类的开销将导致无法忍受的样板代码。但原则上，它可以用于解决与在fp中使用monad解决的问题相同的问题。

来自维基百科：

在函数式编程中，monad是一种抽象数据类型，用于表示计算（而不是域模型中的数据）。Monads公司允许程序员链接动作一起构建管道，其中每个动作都用提供了其他处理规则莫纳德。编写的程序功能性风格可以利用monads来构造程序包括顺序操作，1[2]或定义任意控制流（如处理并发，延续或例外）。形式上，monad由定义两个操作（bind和return）和类型构造函数M必须满足几个财产才能允许正确组成一元函数（即使用monad中的值作为参数）。返回操作需要一个普通类型的值，并将其放入装入M型一元容器中。绑定操作执行反向处理，提取集装箱的原始价值，以及将其传递给关联的下一个函数。程序员将编写monadic定义数据处理的函数管道monad充当框架，因为它是一种可重用的行为这决定了调用管道，并管理所有需要的卧底工作计算[3] 绑定和返回管道中交错的运算符将在每个monadic之后执行函数返回控制，并将注意特定方面由monad处理。

我相信这很好地解释了这一点。

看到我对“什么是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;
}

monad在OO中是否具有“自然”解释取决于monad。在像Java这样的语言中，您可以将may monad转换为检查空指针的语言，这样失败的计算（即，在Haskell中生成Nothing）会将空指针作为结果发出。您可以将状态monad转换为通过创建可变变量和更改其状态的方法生成的语言。

monad是内函子范畴中的幺半群。

这句话所表达的信息非常深刻。你在一个monad中使用任何命令式语言。monad是一种“有序”的领域特定语言。它满足某些有趣的财产，这些属性使单子函数成为“命令式编程”的数学模型。Haskell使定义小型（或大型）命令式语言变得容易，这些语言可以以多种方式组合。

作为一名OO程序员，您使用语言的类层次结构来组织可以在上下文中调用的函数或过程的类型，即您所称的对象。monad也是对这个概念的抽象，因为不同的monad可以以任意方式组合，有效地将所有子monad的方法“导入”到范围中。

从体系结构上讲，然后使用类型签名来明确表示可以使用哪些上下文来计算值。

可以使用monad转换器来实现这一目的，并且有一个高质量的所有“标准”monad集合：

列表（通过将列表视为域进行非确定性计算）可能（计算可能失败，但报告不重要）错误（可能失败并需要异常处理的计算Reader（可以由普通Haskell函数组合表示的计算）编写器（使用顺序“渲染”/“记录”（到字符串、html等）进行计算）续（续）IO（取决于底层计算机系统的计算）状态（上下文包含可修改值的计算）

具有相应的monad变压器和类型类别。类型类允许通过统一monad的接口来组合monad，从而使具体monad可以实现monad“类”的标准接口。例如，模块Control.Monad.State包含一个类MonadState s m，（State s）是表单的一个实例

instance MonadState s (State s) where
    put = ...
    get = ...

长话短说，monad是一个函子，它将“上下文”附加到一个值上，它可以向monad中注入一个值，并且可以根据附加到它上的上下文来评估值，至少是以受限的方式。

So:

return :: a -> m a

是一个函数，它将a类型的值注入到m类型的monad“action”中。

(>>=) :: m a -> (a -> m b) -> m b

是一个执行monad操作、评估其结果并将函数应用于结果的函数。（>>=）的妙处在于结果在同一个monad中。换句话说，在m>>=f中，（>>=）从m中提取结果，并将其绑定到f，这样结果就在monad中。（或者，我们可以说（>>=）将f拉入m，并将其应用于结果。）因此，如果我们有f:：a->m b和g:：b->m c，我们可以“排序”动作：

m >>= f >>= g

或者，使用“do符号”

do x <- m
   y <- f x
   g y

（>>）的类型可能是发光的。它是

(>>) :: m a -> m b -> m b

它对应于C等过程语言中的（；）运算符。它允许使用以下表示法：

m = do x <- someQuery
       someAction x
       theNextAction
       andSoOn

在数学和哲学逻辑中，我们有框架和模型，这些框架和模型“自然”地用单子主义建模。解释是一种函数，它查看模型的域，并计算命题（或公式，在推广下）的真值（或推广）。在必要性的模态逻辑中，我们可能会说，如果命题在“每个可能的世界”中都是真的，那么它是必要的——如果它在每个可容许的域中都是真实的。这意味着命题语言中的模型可以具体化为一个模型，其域由不同模型的集合组成（一个对应于每个可能的世界）。每个monad都有一个名为“join”的方法，该方法将分层，这意味着结果为monad动作的每个monad动作都可以嵌入到monad中。

join :: m (m a) -> m a

更重要的是，这意味着monad在“层堆叠”操作下关闭。这就是monad转换器的工作原理：它们通过为以下类型提供“类联接”方法来组合monad：

newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) }

这样我们就可以将（MaybeT m）中的作用转换为m中的作用，有效地折叠层。在本例中，runMaybeT：：MaybeT m a->m（Maybe a）是我们的类联接方法。（MaybeT m）是一个monad，MaybeT：：m（Maybe a）->MaybeT ma实际上是m中一个新类型monad动作的构造函数。

函子的自由单元是通过堆叠f生成的单元，这意味着f的每个构造函数序列都是自由单元的元素（或者更确切地说，是与f的构造函数序列树形状相同的元素）。自由单体是一种用最少的锅炉板构建柔性单体的有用技术。在Haskell程序中，我可能会使用自由monad来为“高级系统编程”定义简单monad，以帮助维护类型安全（我只是在使用类型及其声明。使用组合子可以直接实现）：

data RandomF r a = GetRandom (r -> a) deriving Functor
type Random r a = Free (RandomF r) a


type RandomT m a = Random (m a) (m a) -- model randomness in a monad by computing random monad elements.
getRandom     :: Random r r
runRandomIO   :: Random r a -> IO a (use some kind of IO-based backend to run)
runRandomIO'  :: Random r a -> IO a (use some other kind of IO-based backend)
runRandomList :: Random r a -> [a]  (some kind of list-based backend (for pseudo-randoms))

Monastem是您可能称之为“解释器”或“命令”模式的基础架构，抽象为最清晰的形式，因为每个单元计算都必须“运行”，至少是微不足道的。（运行时系统为我们运行IO monad，是任何Haskell程序的入口点。IO通过按顺序运行IO操作来“驱动”其余的计算）。

join的类型也是我们得到monad是内函子范畴中的幺半群的陈述的地方。由于其类型，联接对于理论目的来说通常更为重要。但了解类型意味着了解单子。Join和monad变换器的类Join类型在函数组合的意义上是内函子的有效组合。把它放在类似Haskell的伪语言中，

Foo:：m（m a）<->（m.m）a

从实践的角度来看（总结了之前许多回答和相关文章中所说的内容），在我看来，monad的一个基本“目的”（或有用性）是利用递归方法调用（即函数组合）中隐含的依赖关系（即，当f1调用f2调用f3时，f3需要在f1之前的f2之前求值），以自然的方式表示顺序组合，特别是在惰性评估模型的上下文中（即，作为一个普通序列的顺序合成，例如C中的“f3（）；f2（）；f1（）；”），如果你想到f3、f2和f1实际上什么都不返回的情况（它们作为f1（f2（f3））的链接是人为的，纯粹是为了创建序列），那么这个技巧就特别明显了。

当涉及到副作用时，这一点尤其重要，即当某些状态被改变时（如果f1、f2、f3没有副作用，那么它们的求值顺序无关紧要；这是纯函数语言的一个很好的特性，例如能够并行化这些计算）。函数越纯越好。

我认为，从这个狭隘的角度来看，monad可以被视为支持惰性求值的语言的语法糖（只有在绝对必要时才求值，遵循不依赖于代码表示的顺序），并且没有其他表示顺序合成的方法。最终的结果是，“不纯”（即确实有副作用）的代码段可以以命令式的方式自然呈现，但与纯函数（没有副作用）完全分离，纯函数可以延迟求值。

正如这里所警告的，这只是一个方面。

我能想到的最简单的解释是，单声道是一种用符号化结果组成函数的方式（也称为克莱斯利合成）。“embelished”函数具有签名a->（b，smth），其中a和b是可能彼此不同但不一定不同的类型（想想Int，Bool），smth是“上下文”或“embelisement”。

这种类型的函数也可以写成a->m b，其中m相当于“embelisation”smth。因此，这些是在上下文中返回值的函数（想想记录其操作的函数，其中smth是日志消息；或者执行输入/输出的函数，其结果取决于IO操作的结果）。

monad是一个接口（“typeclass”），它让实现者告诉它如何组合这样的函数。实现者需要为任何想要实现接口的m类型定义一个组合函数（a->mb）->（b->mc）->（a->mc）（这是Kleisli组合）。

所以，如果我们说我们有一个元组类型（Int，String），它表示Int上的计算结果，（_，String）是“embelisation”-动作的日志-和两个函数increment：：Int->（Int，String）和twoTimes:：Int->（Int、String），我们希望获得一个函数incamentThenDouble:：Int-＞（Int），这是两个函数的组合，也考虑了日志。

在给定的示例中，两个函数的monad实现应用于整数值2增量ThenDouble 2（等于2倍（增量2））将返回（6，“加法1”。中间结果的增量2等于（3，“加1”），2乘以3等于（6，“加3”）

从这个Kleisli合成函数可以导出通常的一元函数。