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      }

如果我理解正确的话，IEnumerable是从monad派生出来的。我想知道，对于我们这些来自C#世界的人来说，这可能是一个有趣的视角吗？

值得一提的是，这里有一些帮助我的教程链接（不，我还不知道单子是什么）。

http://osteele.com/archives/2007/12/overloading-semicolonhttp://spbhug.folding-maps.org/wiki/MonadsEnhttp://www.loria.fr/~kow/monads/

另一种尝试是解释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最简单的方法是在上下文中应用/组合函数。假设你有两个计算，它们都可以看作是两个数学函数f和g。

f取一个String并生成另一个String（取前两个字母）g获取一个String并生成另一个String（大写转换）

因此，在任何语言中，“取前两个字母并将其转换为大写”的转换都会写成g（f（“某个字符串”））。因此，在纯完美函数的世界中，合成只是：先做一件事，然后再做另一件事。

但假设我们生活在一个功能可能失败的世界中。例如：输入字符串可能有一个字符长，因此f将失败。所以在这种情况下

f获取一个String并生成一个String或Nothing。g仅在f未失败时生成字符串。否则，将不生成任何内容

所以现在，g（f（“somestring”））需要一些额外的检查：“计算f，如果它失败，那么g应该返回Nothing，否则计算g”

此思想可应用于任何参数化类型，如下所示：

让Context[Sometype]是Context中Sometype的计算。考虑功能

f： ：AnyType->上下文[Sometype]g： ：某些类型->上下文[AnyOtherType]

合成g（f（））应该读作“compute f。在这个上下文中，做一些额外的计算，然后计算g，如果它在上下文中有意义”

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

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

解释

当用C#/Java术语解释时，这很简单：

monad是一个接受参数并返回特殊类型的函数。这个monad返回的特殊类型也称为monad。（monad是#1和#2的组合）有一些语法糖可以使调用此函数和类型转换更容易。

实例

monad有助于使函数式程序员的生活更轻松。典型示例：Maye monad接受两个参数，一个值和一个函数。如果传递的值为null，则返回null。否则它将计算函数。如果我们需要一个特殊的返回类型，我们也可以调用这个返回类型Maybe。一个非常粗糙的实现如下所示：

object Maybe(object value, Func<object,object> function)
{
    if(value==null)
        return null;

    return function(value);
}

这在C#中是非常无用的，因为这种语言缺乏使monad有用所需的语法糖。但是monad允许您用函数式编程语言编写更简洁的代码。

通常程序员在链中调用monad，如下所示：

var x = Maybe(x, x2 => Maybe(y, y2 => Add(x2, y2)));

在本例中，只有当x和y都为非null时，才会调用Add方法，否则将返回null。

答复

回答最初的问题：monad是一个函数和一个类型。就像一个特殊接口的实现。