在Coursera“反应式编程原理”培训中，Erik Meier将其描述为：

"Monads are return types that guide you through the happy path." -Erik Meijer

除了上面出色的答案之外，让我为您提供以下文章的链接（由Patrick Thomson撰写），该文章通过将概念与JavaScript库jQuery（及其使用“方法链接”来操作DOM的方式）相关联来解释monads：jQuery是Monad

jQuery文档本身并没有提到术语“monad”，而是谈到了可能更熟悉的“构建器模式”。这并不能改变一个事实，那就是你有一个合适的monad，也许你甚至没有意识到它。

另一种尝试是解释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))

一个非常简单的答案是：

Monad是一种抽象，它为封装值、计算新的封装值和展开封装值提供了接口。

它们在实践中的方便之处在于，它们提供了一个统一的接口，用于创建建模状态而非状态的数据类型。

必须理解Monad是一种抽象，即用于处理某种数据结构的抽象接口。然后，该接口用于构建具有一元行为的数据类型。

你可以在Ruby中的Monads中找到一个非常好且实用的介绍，第1部分：简介。

http://mikehadlow.blogspot.com/2011/02/monads-in-c-8-video-of-my-ddd9-monad.html

这是你要找的视频。

用C#演示组合和对齐类型的问题，然后用C#正确实现它们。最后，他展示了F#和Haskell中相同的C#代码的外观。

实际上，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解析器组合器库时。（也就是说，根据我的经验）

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