monad是一个函数数组

（Pst：函数数组只是一个计算）。

实际上，这些函数不是真正的数组（一个单元格数组中的一个函数），而是由另一个函数>>=链接。>>=允许调整函数i的结果以馈送函数i+1，并在它们之间执行计算或者甚至不调用函数i+1。

这里使用的类型是“带上下文的类型”。这是一个带有“标记”的值。被链接的函数必须采用“裸值”并返回标记结果。>>=的职责之一是从上下文中提取裸值。还有一个函数“return”，它接受一个裸值并将其与一个标记一起放置。

Maybe的一个例子。让我们使用它来存储一个简单的整数，以便进行计算。

-- a * b
multiply :: Int -> Int -> Maybe Int
multiply a b = return  (a*b)

-- divideBy 5 100 = 100 / 5
divideBy :: Int -> Int -> Maybe Int
divideBy 0 _ = Nothing -- dividing by 0 gives NOTHING
divideBy denom num = return (quot num denom) -- quotient of num / denom

-- tagged value
val1 = Just 160 

-- array of functions feeded with val1
array1 = val1 >>= divideBy 2  >>= multiply 3 >>= divideBy  4 >>= multiply 3

-- array of funcionts created with the do notation
-- equals array1 but for the feeded val1
array2 :: Int -> Maybe Int
array2 n = do
       v <- divideBy 2  n
       v <- multiply 3 v
       v <- divideBy 4 v
       v <- multiply 3 v
       return v

-- array of functions, 
-- the first >>= performs 160 / 0, returning Nothing
-- the second >>= has to perform Nothing >>= multiply 3 ....
-- and simply returns Nothing without calling multiply 3 ....
array3 = val1 >>= divideBy 0  >>= multiply 3 >>= divideBy  4 >>= multiply 3

main = do
     print array1
     print (array2 160)
     print array3

为了说明monad是带有助手操作的函数数组，请考虑与上述示例等效，仅使用一个实函数数组

type MyMonad = [Int -> Maybe Int] -- my monad as a real array of functions

myArray1 = [divideBy 2, multiply 3, divideBy 4, multiply 3]

-- function for the machinery of executing each function i with the result provided by function i-1
runMyMonad :: Maybe Int -> MyMonad -> Maybe Int
runMyMonad val [] = val
runMyMonad Nothing _ = Nothing
runMyMonad (Just val) (f:fs) = runMyMonad (f val) fs

它的用法如下：

print (runMyMonad (Just 160) myArray1)

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

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

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

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

这里有一个简单的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[（）]）“尝试…捕捉”等。

典型用法中的Monad在功能上等同于过程编程的异常处理机制。

在现代过程语言中，在一系列语句周围放置一个异常处理程序，其中任何语句都可能引发异常。如果任何语句引发异常，则语句序列的正常执行将停止并转移到异常处理程序。

然而，函数式编程语言在哲学上避免了异常处理特性，因为它们的“goto”性质类似。函数编程的观点是，函数不应该有“副作用”，比如中断程序流的异常。

实际上，由于I/O的原因，在现实世界中不能排除副作用。函数式编程中的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;
}