monad实际上是“类型运算符”的一种形式。它将做三件事。首先，它会将一种类型的值“包装”（或以其他方式转换）为另一种类型（通常称为“一元类型”）。第二，它将使底层类型上的所有操作（或函数）在monadic类型上可用。最后，它将为将自身与另一个monad组合以生成复合monad提供支持。

“可能monad”本质上等同于Visual Basic/C#中的“可为null的类型”。它接受不可为null的类型“T”并将其转换为“可为null＜T＞”，然后定义所有二进制运算符在可为null＞＜T＞上的含义。

副作用也有类似的表现。创建了一个结构，该结构包含函数返回值旁边的副作用描述。当值在函数之间传递时，“提升”操作会复制副作用。

它们被称为“monad”，而不是更容易理解的“类型运算符”的名称，原因如下：

Monad对他们的行为有限制（详见定义）。这些限制，加上涉及三个运算，符合范畴理论中一个叫做monad的结构，这是一个模糊的数学分支。它们是由“纯”函数语言的支持者设计的纯函数语言的支持者，如模糊的数学分支由于数学晦涩难懂，而且monad与特定的编程风格相关，人们倾向于使用monad这个词作为一种秘密握手。正因为如此，没有人费心去投资一个更好的名字。

实际上，monad基本上允许回调嵌套（具有相互递归的线程状态（请忽略连字符））（以可组合（或可分解）的方式）（具有类型安全性（有时（取决于语言）））)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

例如，这不是单子：

//JavaScript is 'Practical'
var getAllThree = 
         bind(getFirst, function(first){  
  return bind(getSecond,function(second){  
  return bind(getThird, function(third){  
    var fancyResult = // And now make do fancy 
                      // with first, second,
                      // and third 
    return RETURN(fancyResult);
  });});});  

但是monad启用了这样的代码。monad实际上是一组类型：{bind，RETURN，也许其他我不认识的人…}。这本质上是无关紧要的，实际上是不切实际的。

所以现在我可以使用它：

var fancyResultReferenceOutsideOfMonad =  
  getAllThree(someKindOfInputAcceptableToOurGetFunctionsButProbablyAString);  

//Ignore this please, throwing away types, yay JavaScript:
//  RETURN = K
//  bind = \getterFn,cb -> 
//    \in -> let(result,newState) = getterFn(in) in cb(result)(newState)

或将其分解：

var getFirstTwo = 
           bind(getFirst, function(first){  
    return bind(getSecond,function(second){  
      var fancyResult2 = // And now make do fancy 
                         // with first and second
      return RETURN(fancyResult2);
    });})
  , getAllThree = 
           bind(getFirstTwo, function(fancyResult2){  
    return bind(getThird,    function(third){  
      var fancyResult3 = // And now make do fancy 
                         // with fancyResult2,
                         // and third 
      return RETURN(fancyResult3);
    });});

或者忽略某些结果：

var getFirstTwo = 
           bind(getFirst, function(first){  
    return bind(getSecond,function(second){  
      var fancyResult2 = // And now make do fancy 
                         // with first and second
      return RETURN(fancyResult2);
    });})
  , getAllThree = 
           bind(getFirstTwo, function(____dontCare____NotGonnaUse____){  
    return bind(getThird,    function(three){  
      var fancyResult3 = // And now make do fancy 
                         // with `three` only!
      return RETURN(fancyResult3);
    });});

或者从以下内容简化一个小案例：

var getFirstTwo = 
           bind(getFirst, function(first){  
    return bind(getSecond,function(second){  
      var fancyResult2 = // And now make do fancy 
                         // with first and second
      return RETURN(fancyResult2);
    });})
  , getAllThree = 
           bind(getFirstTwo, function(_){  
    return bind(getThird,    function(three){  
      return RETURN(three);
    });});

收件人（使用“正确身份”）：

var getFirstTwo = 
           bind(getFirst, function(first){  
    return bind(getSecond,function(second){  
      var fancyResult2 = // And now make do fancy 
                         // with first and second
      return RETURN(fancyResult2);
    });})
  , getAllThree = 
           bind(getFirstTwo, function(_){  
    return getThird;
    });

或者把它们挤在一起：

var getAllThree = 
           bind(getFirst, function(first_dontCareNow){  
    return bind(getSecond,function(second_dontCareNow){  
    return getThird;
    });});

这些能力的实用性并没有真正显现出来，或者变得清晰，直到你试图解决真正的棘手问题例如解析或模块/ajax/资源加载。

你能想象成千上万行indexOf/subString逻辑吗？如果频繁的解析步骤包含在小函数中呢？像字符、空格、大写字符或数字这样的函数？如果这些函数在回调中给出了结果，而不必与Regex集团和争论发生冲突？如果它们的组成/分解被很好地理解了呢？这样你就可以从下往上构建大型解析器了吗？

因此，管理嵌套回调范围的能力非常实用，尤其是在使用monadic解析器组合器库时。（也就是说，根据我的经验）

不要挂断电话：-分类理论-可能是月-莫纳德定律-哈斯克尔- !!!!

解释“什么是monad”有点像说“什么是数字？”我们总是使用数字。但想象一下，你遇到了一个对数字一无所知的人。你怎么解释数字是什么？你怎么开始描述为什么这可能有用？

什么是单子？简单的回答是：这是一种将操作链接在一起的特定方式。

本质上，您正在编写执行步骤，并将它们与“绑定函数”链接在一起。（在Haskell中，它名为>>=。）您可以自己编写对绑定运算符的调用，也可以使用语法糖，使编译器为您插入这些函数调用。但无论哪种方式，每个步骤都由对该绑定函数的调用分隔。

因此绑定函数就像分号；它将流程中的步骤分开。bind函数的任务是获取上一步的输出，并将其输入下一步。

听起来不太难，对吧？但单子不止一种。为什么？怎样

好吧，bind函数可以从一个步骤中获取结果，并将其传递给下一个步骤。但如果这就是单子的全部。。。这实际上不是很有用。理解这一点很重要：每个有用的monad除了做monad之外，还做其他事情。每一个有用的单子都有一种“特殊的力量”，这使它独一无二。

（没有什么特别作用的monad被称为“身份monad”。与身份函数类似，这听起来是一件毫无意义的事情，但事实证明并非如此……但这是另一回事™.)

基本上，每个monad都有自己的绑定函数实现。你可以编写一个绑定函数，这样它就可以在执行步骤之间做一些傻事。例如：

如果每个步骤都返回一个成功/失败指示符，则只有在前一个步骤成功的情况下，才能让绑定执行下一个步骤。这样，失败的步骤“自动”中止整个序列，而无需您进行任何条件测试。（故障单）扩展这个想法，您可以实现“异常”。（错误单点或异常单点。）因为您自己定义它们，而不是将其作为一种语言特性，所以您可以定义它们的工作方式。（例如，您可能希望忽略前两个异常，仅在引发第三个异常时中止。）您可以使每个步骤返回多个结果，并让bind函数对其进行循环，将每个结果输入到下一步。这样，在处理多个结果时，就不必一直到处写循环。绑定函数“自动”为您完成所有这些。（单子）除了将“结果”从一个步骤传递到另一个步骤之外，还可以让bind函数传递额外的数据。这些数据现在不会显示在源代码中，但您仍然可以从任何地方访问它，而无需手动将其传递给每个函数。（《读者》杂志）您可以这样做，以便可以替换“额外数据”。这允许您模拟破坏性更新，而无需实际执行破坏性更新。（莫纳德州及其堂弟作家莫纳德。）因为您只是在模拟破坏性更新，所以您可以轻松地完成真正的破坏性更新所无法完成的事情。例如，您可以撤消上一次更新，或恢复到旧版本。你可以制作一个可以暂停计算的monad，这样你就可以暂停你的程序，进入并修补内部状态数据，然后恢复它。您可以将“continuations”实现为monad。这可以让你打破人们的想法！

所有这些和更多的都可以通过monad实现。当然，这一切在没有单子的情况下也是完全可能的。使用monad非常简单。

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

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

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

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

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

在Scala的上下文中，您会发现以下是最简单的定义。基本上，flatMap（或bind）是“关联”的，并且存在一个标识。

trait M[+A] {
  def flatMap[B](f: A => M[B]): M[B] // AKA bind

  // Pseudo Meta Code
  def isValidMonad: Boolean = {
    // for every parameter the following holds
    def isAssociativeOn[X, Y, Z](x: M[X], f: X => M[Y], g: Y => M[Z]): Boolean =
      x.flatMap(f).flatMap(g) == x.flatMap(f(_).flatMap(g))

    // for every parameter X and x, there exists an id
    // such that the following holds
    def isAnIdentity[X](x: M[X], id: X => M[X]): Boolean =
      x.flatMap(id) == x
  }
}

E.g.

// These could be any functions
val f: Int => Option[String] = number => if (number == 7) Some("hello") else None
val g: String => Option[Double] = string => Some(3.14)

// Observe these are identical. Since Option is a Monad 
// they will always be identical no matter what the functions are
scala> Some(7).flatMap(f).flatMap(g)
res211: Option[Double] = Some(3.14)

scala> Some(7).flatMap(f(_).flatMap(g))
res212: Option[Double] = Some(3.14)


// As Option is a Monad, there exists an identity:
val id: Int => Option[Int] = x => Some(x)

// Observe these are identical
scala> Some(7).flatMap(id)
res213: Option[Int] = Some(7)

scala> Some(7)
res214: Some[Int] = Some(7)

注：严格地说，函数编程中的Monad的定义与范畴理论中的Monard的定义不同，后者是按映射和展平的顺序定义的。尽管它们在某些映射下是等价的。这个演示非常好：http://www.slideshare.net/samthemonad/monad-presentation-scala-as-a-category

另一种尝试是解释monad，只使用Python列表和map函数。我完全接受这不是一个完整的解释，但我希望它能触及核心概念。

我从Monads上的funfunfunction视频和Learn You A Haskell章节“为了几个Monads更多”中得到了这一点的基础。我强烈推荐观看funfunfunction视频。

最简单的是，Monad是具有map和flatMap函数（在Haskell中绑定）的对象。有一些额外的必需财产，但这些是核心属性。

flatMap“展平”map的输出，对于列表，这只是连接列表的值，例如。

concat([[1], [4], [9]]) = [1, 4, 9]

因此，在Python中，我们基本上可以通过以下两个函数实现Monad：

def flatMap(func, lst):
    return concat(map(func, lst))

def concat(lst):
    return sum(lst, [])

func是任何接受值并返回列表的函数。

lambda x: [x*x]

解释

为了清楚起见，我通过一个简单的函数在Python中创建了concat函数，该函数将列表相加，即[]+[1]+[4]+[9]=[1，4，9]（Haskell有一个原生的concat方法）。

我假设你知道地图功能是什么，例如：

>>> list(map(lambda x: [x*x], [1,2,3]))
[[1], [4], [9]]

展平是Monad的关键概念，对于每个作为Monad的对象，这种展平允许您获得Monad中包裹的值。

现在我们可以呼叫：

>>> flatMap(lambda x: [x*x], [1,2,3])
[1, 4, 9]

这个lambda取一个值x并将其放入一个列表中。monad适用于从值到monad类型的任何函数，所以在本例中是列表。

这是你的monad定义。

我认为为什么它们有用的问题已经在其他问题中得到了回答。

更多说明

其他不是列表的例子有JavaScript Promise，它有then方法，JavaScript Streams有flatMap方法。

因此Promise和Streams使用了一个稍微不同的函数，它将Stream或Promise展平，并从内部返回值。

Haskell列表monad具有以下定义：

instance Monad [] where  
    return x = [x]  
    xs >>= f = concat (map f xs)  
    fail _ = [] 

即有三个函数return（不要与大多数其他语言中的return混淆）、>>=（flatMap）和fail。

希望您能看到以下两者之间的相似之处：

xs >>= f = concat (map f xs)

and:

def flatMap(f, xs):
    return concat(map(f, xs))