我将尝试在Haskell的背景下解释Monad。

在函数式编程中，函数组合很重要。它允许我们的程序由小的、易于阅读的函数组成。

假设我们有两个函数：g:：Int->String和f:：String->Bool。

我们可以做（f.g）x，这与f（gx）相同，其中x是Int值。

当进行合成/将一个函数的结果应用到另一个函数时，使类型匹配是很重要的。在上述情况下，g返回的结果类型必须与f接受的类型相同。

但有时值是在上下文中的，这使得排列类型有点不容易。（在上下文中设置值非常有用。例如，Maybe Int类型表示可能不存在的Int值，IO String类型表示由于执行某些副作用而存在的String值。）

假设我们现在有g1：：Int->Maybe String和f1：：String->Maybe Bool。g1和f1分别与g和f非常相似。

我们不能做（f1.g1）x或f1（g1 x），其中x是Int值。g1返回的结果类型不是f1期望的类型。

我们可以用。运算符，但现在我们不能用..组合f1和g1。。问题是我们不能直接将上下文中的值传递给期望值不在上下文中的函数。

如果我们引入一个运算符来组合g1和f1，这样我们就可以写出（f1 operator g1）x，这不是很好吗？g1返回上下文中的值。该值将脱离上下文并应用于f1。是的，我们有这样一个操作员。它是<=<。

我们还有一个>>=运算符，它为我们做了完全相同的事情，尽管语法略有不同。

我们写：g1 x>>=f1。g1 x是Maybe Int值。>>=运算符帮助将Int值从“可能不存在”上下文中取出，并将其应用于f1。f1的结果是Maybe Bool，它将是整个>>=操作的结果。

最后，为什么Monad有用？因为Monad是定义>>=运算符的类型类，与定义==和/=运算符的Eq类型类非常相似。

总之，Monad类型类定义了>>=运算符，该运算符允许我们将上下文中的值（我们称为这些monadic值）传递给不需要上下文中值的函数。将考虑上下文。

如果这里需要记住一点，那就是Monads允许在上下文中包含值的函数组合。

但是，你本可以发明蒙纳斯！

sigfpe说：但所有这些都将单子介绍为需要解释的深奥的东西。但我想说的是，它们一点都不深奥。事实上，面对函数式编程中的各种问题，你会不可避免地被引向某些解决方案，所有这些都是单子的例子。事实上，如果你还没有发明，我希望你现在就发明它们。这是注意到所有这些解决方案实际上都是变相的相同解决方案的一小步。读完这篇文章后，你可能会更好地理解单子上的其他文档，因为你会发现你所看到的一切都是你已经发明的。monads试图解决的许多问题都与副作用有关。因此，我们将从它们开始。（请注意，monad让您做的不仅仅是处理副作用，特别是许多类型的容器对象都可以被视为monad。monad的一些介绍发现，很难协调monad的这两种不同用法，并且只关注其中一种。）在命令式编程语言（如C++）中，函数的行为与数学函数完全不同。例如，假设我们有一个C++函数，它接受一个浮点参数并返回一个浮点结果。从表面上看，它可能有点像一个将实数映射到实数的数学函数，但C++函数可以做的不仅仅是返回一个依赖于其参数的数字。它可以读取和写入全局变量的值，也可以将输出写入屏幕并接收用户的输入。然而，在纯函数语言中，函数只能读取在其参数中提供给它的内容，而它对世界产生影响的唯一方式是通过它返回的值。

monad是一种将共享共同上下文的计算组合在一起的方法。这就像建立一个管道网络。当构建网络时，没有数据流过它。但是当我用“bind”和“return”将所有位拼接在一起后，我调用类似runMyMonad monad数据的东西，数据流过管道。

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

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

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

Monad是一个可应用的（即，你可以将二进制（因此，“n元”）函数提升到（1），并将纯值注入（2））Functor（即，可以映射到（3）的函数，即提升一元函数到（3”），它还具有展平嵌套数据类型的能力（三个概念中的每一个都遵循其相应的一组规则）。在Haskell中，这种扁平化操作称为join。

此“联接”操作的常规（通用、参数化）类型为：

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

对于任何monad m（注意，类型中的所有ms都是相同的！）。

特定的m monad定义了其特定版本的join，该版本适用于由类型m A的monadic值“携带”的任何值类型A。某些特定类型包括：

join  ::  [[a]]           -> [a]         -- for lists, or nondeterministic values
join  ::  Maybe (Maybe a) -> Maybe a     -- for Maybe, or optional values
join  ::  IO    (IO    a) -> IO    a     -- for I/O-produced values

连接操作将产生a型值的m计算的m计算转换为a型值组合的m计算。这允许将计算步骤组合成一个更大的计算。

结合“bind”（>>=）运算符的计算步骤简单地使用fmap和join，即。

(ma >>= k)  ==  join (fmap k ma)
{-
  ma        :: m a            -- `m`-computation which produces `a`-type values
  k         ::   a -> m b     --  create new `m`-computation from an `a`-type value
  fmap k ma :: m    ( m b )   -- `m`-computation of `m`-computation of `b`-type values
  (m >>= k) :: m        b     -- `m`-computation which produces `b`-type values
-}

相反，可以通过bind定义join，join mma==join（fmap id mma）==mma>>=id，其中id ma=ma——对于给定的类型m，以更方便的为准。

对于monad，do表示法及其使用代码的等效绑定，

do { x <- mx ; y <- my ; return (f x y) }        --   x :: a   ,   mx :: m a
                                                 --   y :: b   ,   my :: m b
mx >>= (\x ->                                    -- nested
            my >>= (\y ->                        --  lambda
                         return (f x y) ))       --   functions

可以读为

首先“做”mx，当它完成时，将其“结果”作为x，让我用它“做”其他事情。

在给定的do块中，绑定箭头<-右侧的每个值对于某些类型a都是m a类型，在整个do块中都是相同的monad m。

返回x是一个中立的m计算，它只产生给定的纯值x，因此将任何m计算与返回绑定都不会改变该计算。

（1） 提升A2：：适用m=>（a->b->c）->m a->m b->m c

（2） 纯：：适用m=>a->m a

（3） 具有fmap：：函数m=>（a->b）->m a->m b

还有等效的Monad方法，

liftM2 :: Monad m => (a -> b -> c) -> m a -> m b -> m c
return :: Monad m =>  a            -> m a
liftM  :: Monad m => (a -> b)      -> m a -> m b

给定monad，其他定义可以如下

pure   a       = return a
fmap   f ma    = do { a <- ma ;            return (f a)   }
liftA2 f ma mb = do { a <- ma ; b <- mb  ; return (f a b) }
(ma >>= k)     = do { a <- ma ; b <- k a ; return  b      }

最近我一直在以不同的方式思考莫纳斯。我一直认为它们以数学的方式抽象出执行顺序，这使得新类型的多态性成为可能。

如果您使用的是命令式语言，并且您按照顺序编写一些表达式，那么代码始终按照该顺序运行。

在简单的例子中，当你使用monad时，感觉是一样的——你定义了一个按顺序发生的表达式列表。除此之外，根据您使用的monad，您的代码可能会按顺序运行（如IO monad），同时在多个项目上并行运行（如List monad）；它可能会中途停止（如Maybe monad）。它可能会在中途暂停以稍后恢复（如Resume monad）），或者它可能会中途倒带以尝试其他选项（如逻辑单声道）。

因为monad是多态的，所以可以根据需要在不同的monad中运行相同的代码。

此外，在某些情况下，可以将monad组合在一起（使用monad转换器）以同时获得多个特性。