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

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

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

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

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

我也在努力理解单子。这是我的版本：

Monad是关于对重复的事物进行抽象的。首先，monad本身是一个类型化接口（像抽象泛型类），它有两个函数：bind和return，它们定义了签名。然后，我们可以基于抽象的monad创建具体的monad，当然还有绑定和返回的具体实现。此外，绑定和返回必须满足几个不变量，以便可以组合/链接具体的单体。

当我们有接口、类型、类和其他工具来创建抽象时，为什么要创建monad概念？因为monad提供了更多：它们以一种能够在没有任何样板的情况下合成数据的方式强制重新思考问题。

对于来自命令式背景（c#）的人，

考虑以下代码

bool ReturnTrueorFalse(SomeObject input)
{
    if(input.Property1 is invalid)
    {
        return false;
    }

    if(input.Property2 is invalid)
    {
        return false;
    }

    DoSomething();
    return true;
}

您会看到很多这样的代码，甚至不会看到早期返回，但所有检查都是嵌套完成的。现在，Monad是一种模式，它可以像下面一样被压平

Monad<bool> ReturnTrueorFalse(SomeObject input) =>
    from isProperty1Valid in input.Property1
    from isProperty2Valid in input.Property2
    select Monad.Create(isProperty1Valid && isProperty2Valid);

这里有几点需要注意。首先，更改函数的返回值。其次，输入的两个财产都必须是Monad。接下来，Monad应该实现SelectMany（LINQ的展平运算符）。由于SelectMany是为该类型实现的，因此可以使用查询语法编写语句

那幺，什么是莫纳德？它是一种以可组合方式对返回相同类型的表达式进行扁平化的结构。这在函数式编程中特别有用，因为大多数函数式应用程序倾向于将状态和IO保持在应用程序的边缘层（例如：控制器），并在整个调用堆栈中返回基于Monad的返回值，直到需要解包该值。当我第一次看到这张照片时，我最大的优点是它很容易在眼睛上看到，也很有陈腔滥调。

每个c#（现在几乎每个人）开发人员都能立即识别的Monad的最佳示例是async/await。在.Net4.5之前，我们必须使用ContinueWith编写基于任务的语句来处理回调，在async/await之后，我们开始使用同步语法来处理异步语法。这是可能的，因为Task是一个“monad”。

关于OOP开发人员的详细说明，请参阅本文，这是一个简单的实现和语言文本，其中包含许多很棒的Monad和大量关于函数式编程的信息

Monad用于控制流，就像抽象数据类型用于数据一样。

换句话说，许多开发人员对集合、列表、字典（或哈希、或地图）和树的概念很熟悉。在这些数据类型中有许多特殊情况（例如InsertionOrderPreservingIdentityHashMap）。

然而，当面对程序“流”时，许多开发人员还没有接触到比if、switch/case、do、while、goto（grr）和（可能）闭包更多的构造。

因此，monad只是一个控制流构造。替代monad的更好短语是“控制类型”。

因此，monad具有用于控制逻辑、语句或函数的槽——数据结构中的等价物是，某些数据结构允许您添加数据，并删除数据。

例如，“if”monad：

if( clause ) then block

最简单的是有两个槽：一个子句和一个块。if monad通常用于评估子句的结果，如果不是false，则评估块。许多开发人员在学习“如果”时并没有接触到monad，而且编写有效的逻辑并不需要理解monad。

monad可能会变得更复杂，就像数据结构可能变得更复杂一样，但monad有很多大类可能具有相似的语义，但实现和语法不同。

当然，数据结构可以在单子上迭代或遍历，也可以以同样的方式进行评估。

编译器可能支持也可能不支持用户定义的monad。哈斯克尔当然知道。Ioke有一些类似的功能，尽管语言中没有使用monad一词。

tl；博士

{-# LANGUAGE InstanceSigs #-}

newtype Id t = Id t

instance Monad Id where
   return :: t -> Id t
   return = Id

   (=<<) :: (a -> Id b) -> Id a -> Id b
   f =<< (Id x) = f x

开场白

应用程序运算符$of函数

forall a b. a -> b

是规范定义的

($) :: (a -> b) -> a -> b
f $ x = f x

infixr 0 $

根据Haskell基函数应用f x（infixl 10）。

作文定义为$as

(.) :: (b -> c) -> (a -> b) -> (a -> c)
f . g = \ x -> f $ g x

infixr 9 .

并且满足所有f g h的等价性。

     f . id  =  f            :: c -> d   Right identity
     id . g  =  g            :: b -> c   Left identity
(f . g) . h  =  f . (g . h)  :: a -> d   Associativity

.是关联的，id是它的右标识和左标识。

克莱斯利三人组

在编程中，monad是带有monad类型类实例的函子类型构造函数。定义和实现有几个等价的变体，每个变体对monad抽象的直觉略有不同。

函子是带有函子类型类实例的*->*类型的类型构造函数f。

{-# LANGUAGE KindSignatures #-}

class Functor (f :: * -> *) where
   map :: (a -> b) -> (f a -> f b)

除了遵循静态强制类型协议之外，函子类型类的实例必须遵守所有f g的代数函子定律。

       map id  =  id           :: f t -> f t   Identity
map f . map g  =  map (f . g)  :: f a -> f c   Composition / short cut fusion

函数计算具有以下类型

forall f t. Functor f => f t

计算c r包含上下文c中的结果r。

一元一元函数或Kleisli箭头的类型为

forall m a b. Functor m => a -> m b

Kleisi箭头是接受一个参数a并返回一元计算m b的函数。

Monads是用Kleisli三重函数定义的

(m, return, (=<<))

实现为类型类

class Functor m => Monad m where
   return :: t -> m t
   (=<<)  :: (a -> m b) -> m a -> m b

infixr 1 =<<

Kleisli标识返回是一个Kleisli箭头，它将值t提升为单元上下文m。

Kleisli组成<=<根据扩展定义为

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> (a -> m c)
f <=< g = \ x -> f =<< g x

infixr 1 <=<

<=<组成两个Kleisli箭头，将左箭头应用于右箭头应用的结果。

monad类型类的实例必须遵守monad定律，这在Kleisli组合中最为优雅地表述为：forall f g h。

   f <=< return  =  f                :: c -> m d   Right identity
   return <=< g  =  g                :: b -> m c   Left identity
(f <=< g) <=< h  =  f <=< (g <=< h)  :: a -> m d   Associativity

<=<是关联的，返回是它的右标识和左标识。

身份

标识类型

type Id t = t

是类型上的标识函数

Id :: * -> *

被解释为函子，

   return :: t -> Id t
=      id :: t ->    t

    (=<<) :: (a -> Id b) -> Id a -> Id b
=     ($) :: (a ->    b) ->    a ->    b

    (<=<) :: (b -> Id c) -> (a -> Id b) -> (a -> Id c)
=     (.) :: (b ->    c) -> (a ->    b) -> (a ->    c)

在规范的Haskell中，定义了身份monad

newtype Id t = Id t

instance Functor Id where
   map :: (a -> b) -> Id a -> Id b
   map f (Id x) = Id (f x)

instance Monad Id where
   return :: t -> Id t
   return = Id

   (=<<) :: (a -> Id b) -> Id a -> Id b
   f =<< (Id x) = f x

选项

选项类型

data Maybe t = Nothing | Just t

编码计算可能t不一定产生结果t，计算可能“失败”。选项monad已定义

instance Functor Maybe where
   map :: (a -> b) -> (Maybe a -> Maybe b)
   map f (Just x) = Just (f x)
   map _ Nothing  = Nothing

instance Monad Maybe where
   return :: t -> Maybe t
   return = Just

   (=<<) :: (a -> Maybe b) -> Maybe a -> Maybe b
   f =<< (Just x) = f x
   _ =<< Nothing  = Nothing

a->Maybe b仅在Maybe a产生结果时应用于结果。

newtype Nat = Nat Int

自然数可以编码为大于或等于零的整数。

toNat :: Int -> Maybe Nat
toNat i | i >= 0    = Just (Nat i)
        | otherwise = Nothing

自然数在减法下不是封闭的。

(-?) :: Nat -> Nat -> Maybe Nat
(Nat n) -? (Nat m) = toNat (n - m)

infixl 6 -?

选项monad涵盖了异常处理的基本形式。

(-? 20) <=< toNat :: Int -> Maybe Nat

List

列表monad，覆盖列表类型

data [] t = [] | t : [t]

infixr 5 :

及其加法幺半群运算“append”

(++) :: [t] -> [t] -> [t]
(x : xs) ++ ys = x : xs ++ ys
[]       ++ ys = ys

infixr 5 ++

编码非线性计算[t]，产生自然量0，1。。。结果t。

instance Functor [] where
   map :: (a -> b) -> ([a] -> [b])
   map f (x : xs) = f x : map f xs
   map _ []       = []

instance Monad [] where
   return :: t -> [t]
   return = (: [])

   (=<<) :: (a -> [b]) -> [a] -> [b]
   f =<< (x : xs) = f x ++ (f =<< xs)
   _ =<< []       = []

Extension=<<将从Kleisli箭头a->[b]的应用f x到[a]的元素的所有列表[b]连接到一个结果列表[b]。

设正整数n的正除数为

divisors :: Integral t => t -> [t]
divisors n = filter (`divides` n) [2 .. n - 1]

divides :: Integral t => t -> t -> Bool
(`divides` n) = (== 0) . (n `rem`)

then

forall n.  let { f = f <=< divisors } in f n   =   []

在定义monad类型类时，Haskell标准使用其flip，即绑定运算符>>=，而不是extension=<<。

class Applicative m => Monad m where
   (>>=) :: forall a b. m a -> (a -> m b) -> m b

   (>>) :: forall a b. m a -> m b -> m b
   m >> k = m >>= \ _ -> k
   {-# INLINE (>>) #-}

   return :: a -> m a
   return = pure

为了简单起见，本解释使用了类型类层次结构

class              Functor f
class Functor m => Monad m

在Haskell中，当前的标准层次结构是

class                  Functor f
class Functor p     => Applicative p
class Applicative m => Monad m

因为不仅每个单子都是函子，而且每个应用格也是函子，每个单子也是应用格。

使用列表monad，命令式伪代码

for a in (1, ..., 10)
   for b in (1, ..., 10)
      p <- a * b
      if even(p)
         yield p

大致翻译为do块，

do a <- [1 .. 10]
   b <- [1 .. 10]
   let p = a * b
   guard (even p)
   return p

等效的monad理解，

[ p | a <- [1 .. 10], b <- [1 .. 10], let p = a * b, even p ]

和表达式

[1 .. 10] >>= (\ a ->
   [1 .. 10] >>= (\ b ->
      let p = a * b in
         guard (even p) >>       -- [ () | even p ] >>
            return p
      )
   )

Do符号和monad理解是嵌套绑定表达式的语法糖。绑定运算符用于一元结果的本地名称绑定。

let x = v in e    =   (\ x -> e)  $  v   =   v  &  (\ x -> e)
do { r <- m; c }  =   (\ r -> c) =<< m   =   m >>= (\ r -> c)

哪里

(&) :: a -> (a -> b) -> b
(&) = flip ($)

infixl 0 &

定义了防护功能

guard :: Additive m => Bool -> m ()
guard True  = return ()
guard False = fail

其中单位类型或“空元组”

data () = ()

支持选择和失败的加法单子可以通过使用类型类抽象

class Monad m => Additive m where
   fail  :: m t
   (<|>) :: m t -> m t -> m t

infixl 3 <|>

instance Additive Maybe where
   fail = Nothing

   Nothing <|> m = m
   m       <|> _ = m

instance Additive [] where
   fail = []
   (<|>) = (++)

其中fail和<|>形成所有k l m的幺半群。

     k <|> fail  =  k
     fail <|> l  =  l
(k <|> l) <|> m  =  k <|> (l <|> m)

失败的是吸收/消灭零元素的加法单体

_ =<< fail  =  fail

如果在

guard (even p) >> return p

即使p为真，则保护产生[（）]，并且根据>>的定义，产生局部常数函数

\ _ -> return p

应用于结果（）。如果为false，则保护生成列表monad的fail（[]），这不会产生要应用>>的Kleisli箭头的结果，因此跳过此p。

状态

不光彩的是，monad用于编码有状态计算。

状态处理器是一种功能

forall st t. st -> (t, st)

转换状态st并产生结果t。状态st可以是任何东西。没有，标志，计数，数组，句柄，机器，世界。

状态处理器的类型通常称为

type State st t = st -> (t, st)

状态处理器monad是kind*->*函子state st.Kleisli状态处理器mond的箭头是函数

forall st a b. a -> (State st) b

在规范的Haskell中，定义了状态处理器monad的惰性版本

newtype State st t = State { stateProc :: st -> (t, st) }

instance Functor (State st) where
   map :: (a -> b) -> ((State st) a -> (State st) b)
   map f (State p) = State $ \ s0 -> let (x, s1) = p s0
                                     in  (f x, s1)

instance Monad (State st) where
   return :: t -> (State st) t
   return x = State $ \ s -> (x, s)

   (=<<) :: (a -> (State st) b) -> (State st) a -> (State st) b
   f =<< (State p) = State $ \ s0 -> let (x, s1) = p s0
                                     in  stateProc (f x) s1

状态处理器通过提供初始状态来运行：

run :: State st t -> st -> (t, st)
run = stateProc

eval :: State st t -> st -> t
eval = fst . run

exec :: State st t -> st -> st
exec = snd . run

状态访问由原语get和put提供，它们是对有状态monad的抽象方法：

{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}

class Monad m => Stateful m st | m -> st where
   get :: m st
   put :: st -> m ()

m->st声明状态类型st对monad m的函数依赖性；例如，状态t将确定状态类型为t唯一。

instance Stateful (State st) st where
   get :: State st st
   get = State $ \ s -> (s, s)

   put :: st -> State st ()
   put s = State $ \ _ -> ((), s)

单位类型类似于C中的空隙。

modify :: Stateful m st => (st -> st) -> m ()
modify f = do
   s <- get
   put (f s)

gets :: Stateful m st => (st -> t) -> m t
gets f = do
   s <- get
   return (f s)

gets通常与记录字段访问器一起使用。

状态monad等价于变量线程

let s0 = 34
    s1 = (+ 1) s0
    n = (* 12) s1
    s2 = (+ 7) s1
in  (show n, s2)

其中s0：：Int，是同样透明的，但更加优雅和实用

(flip run) 34
   (do
      modify (+ 1)
      n <- gets (* 12)
      modify (+ 7)
      return (show n)
   )

modify（+1）是一种类型为State Int（）的计算，但其效果等同于return（）。

(flip run) 34
   (modify (+ 1) >>
      gets (* 12) >>= (\ n ->
         modify (+ 7) >>
            return (show n)
      )
   )

结合性的单子定律可以用>>=forall m f g来表示。

(m >>= f) >>= g  =  m >>= (\ x -> f x >>= g)

or

do {                 do {                   do {
   r1 <- do {           x <- m;                r0 <- m;
      r0 <- m;   =      do {            =      r1 <- f r0;
      f r0                 r1 <- f x;          g r1
   };                      g r1             }
   g r1                 }
}                    }

与面向表达式的编程（例如Rust）一样，块的最后一条语句表示其产量。绑定运算符有时被称为“可编程分号”。

对结构化命令式编程中的迭代控制结构原语进行单点仿真

for :: Monad m => (a -> m b) -> [a] -> m ()
for f = foldr ((>>) . f) (return ())

while :: Monad m => m Bool -> m t -> m ()
while c m = do
   b <- c
   if b then m >> while c m
        else return ()

forever :: Monad m => m t
forever m = m >> forever m

输入/输出

data World

I/O世界状态处理器monad是纯Haskell和真实世界的协调，是功能外延和命令式操作语义的协调。与实际严格执行情况类似：

type IO t = World -> (t, World)

不纯洁的原语促进了交互

getChar         :: IO Char
putChar         :: Char -> IO ()
readFile        :: FilePath -> IO String
writeFile       :: FilePath -> String -> IO ()
hSetBuffering   :: Handle -> BufferMode -> IO ()
hTell           :: Handle -> IO Integer
. . .              . . .

使用IO原语的代码的杂质由类型系统永久协议化。因为纯净是可怕的，在IO中发生的一切，都留在IO中。

unsafePerformIO :: IO t -> t

或者，至少应该。

Haskell程序的类型签名

main :: IO ()
main = putStrLn "Hello, World!"

扩展到

World -> ((), World)

改变世界的函数。

后记

对象是Haskell类型，态射是Haskelr类型之间的函数的类别是，“快速和松散”，类别是Hask。

函子T是从范畴C到范畴D的映射；对于C中的每个对象，D中的一个对象

Tobj :  Obj(C) -> Obj(D)
   f :: *      -> *

对于C中的每个态射，D中的一个态射

Tmor :  HomC(X, Y) -> HomD(Tobj(X), Tobj(Y))
 map :: (a -> b)   -> (f a -> f b)

其中X，Y是C中的对象。HomC（X，Y）是C中所有态射X->Y的同态类。

                    Tmor    Tobj

      T(id)  =  id        : T(X) -> T(X)   Identity
T(f) . T(g)  =  T(f . g)  : T(X) -> T(Z)   Composition

范畴C的Kleisli范畴由Kleisli三元组给出

<T, eta, _*>

内函子的

T : C -> C

（f） 、同一态射eta（return）和扩展运算符*（=<<）。

Hask中的每个Kleisli态射

      f :  X -> T(Y)
      f :: a -> m b

由扩展运算符

   (_)* :  Hom(X, T(Y)) -> Hom(T(X), T(Y))
  (=<<) :: (a -> m b)   -> (m a -> m b)

在Hask的Kleisli范畴中给出了一个态射

     f* :  T(X) -> T(Y)
(f =<<) :: m a  -> m b

Kleisli范畴中的成分。T以扩展的形式给出

 f .T g  =  f* . g       :  X -> T(Z)
f <=< g  =  (f =<<) . g  :: a -> m c

并且满足范畴公理

       eta .T g  =  g                :  Y -> T(Z)   Left identity
   return <=< g  =  g                :: b -> m c

       f .T eta  =  f                :  Z -> T(U)   Right identity
   f <=< return  =  f                :: c -> m d

  (f .T g) .T h  =  f .T (g .T h)    :  X -> T(U)   Associativity
(f <=< g) <=< h  =  f <=< (g <=< h)  :: a -> m d

应用等价变换

     eta .T g  =  g
     eta* . g  =  g               By definition of .T
     eta* . g  =  id . g          forall f.  id . f  =  f
         eta*  =  id              forall f g h.  f . h  =  g . h  ==>  f  =  g

(f .T g) .T h  =  f .T (g .T h)
(f* . g)* . h  =  f* . (g* . h)   By definition of .T
(f* . g)* . h  =  f* . g* . h     . is associative
    (f* . g)*  =  f* . g*         forall f g h.  f . h  =  g . h  ==>  f  =  g

在扩展方面是规范给出的

               eta*  =  id                 :  T(X) -> T(X)   Left identity
       (return =<<)  =  id                 :: m t -> m t

           f* . eta  =  f                  :  Z -> T(U)      Right identity
   (f =<<) . return  =  f                  :: c -> m d

          (f* . g)*  =  f* . g*            :  T(X) -> T(Z)   Associativity
(((f =<<) . g) =<<)  =  (f =<<) . (g =<<)  :: m a -> m c

Monads也可以不使用Kleislian扩展来定义，而是在称为join的编程中使用自然转换mu来定义。一个单元是用μ来定义的，它是一个内函子的范畴C上的三元组

     T :  C -> C
     f :: * -> *

和两种自然变形

   eta :  Id -> T
return :: t  -> f t

    mu :  T . T   -> T
  join :: f (f t) -> f t

满足等效条件

       mu . T(mu)  =  mu . mu               :  T . T . T -> T . T   Associativity
  join . map join  =  join . join           :: f (f (f t)) -> f t

      mu . T(eta)  =  mu . eta       =  id  :  T -> T               Identity
join . map return  =  join . return  =  id  :: f t -> f t

然后定义monad类型类

class Functor m => Monad m where
   return :: t -> m t
   join   :: m (m t) -> m t

选项monad的规范mu实现：

instance Monad Maybe where
   return = Just

   join (Just m) = m
   join Nothing  = Nothing

concat函数

concat :: [[a]] -> [a]
concat (x : xs) = x ++ concat xs
concat []       = []

是列表monad的连接。

instance Monad [] where
   return :: t -> [t]
   return = (: [])

   (=<<) :: (a -> [b]) -> ([a] -> [b])
   (f =<<) = concat . map f

联接的实现可以使用等价项从扩展形式转换

     mu  =  id*           :  T . T -> T
   join  =  (id =<<)      :: m (m t) -> m t

从mu到扩展形式的反向转换如下

     f*  =  mu . T(f)     :  T(X) -> T(Y)
(f =<<)  =  join . map f  :: m a -> m b

---

Philip Wadler:函数编程的MonadsSimon L Peyton Jones，Philip Wadler：强制函数式编程Jonathan M.D.Hill，Keith Clarke：范畴理论、范畴理论单子及其与函数编程的关系简介´Kleisli类别Eugenio Moggi：计算和单子的概念莫纳德不是什么

但为什么如此抽象的理论对编程有用呢？答案很简单：作为计算机科学家，我们重视抽象！当我们设计软件组件的接口时，我们希望它尽可能少地揭示实现。我们希望能够用许多替代方案来替代实现，许多其他“实例”都是相同的“概念”。当我们为许多程序库设计通用接口时，更重要的是我们选择的接口具有多种实现。我们非常重视monad概念的普遍性，这是因为范畴理论非常抽象，所以它的概念对编程非常有用。因此，我们在下面介绍的单子的推广也与范畴理论有着密切的联系，这一点不足为奇。但我们强调，我们的目的非常实用：它不是“实现范畴理论”，而是找到一种更通用的方法来构造组合子库。数学家已经为我们做了很多工作，这是我们的幸运！

从约翰·休斯的《概括单子到箭头》

事实上，与一般人对蒙得斯的理解相反，他们与国家无关。Monads只是一种包装东西的方法，它提供了对包装好的东西进行操作而不展开的方法。

例如，您可以在Haskell中创建一个类型来包装另一个类型：

data Wrapped a = Wrap a

包装我们定义的东西

return :: a -> Wrapped a
return x = Wrap x

要在不展开的情况下执行操作，假设您有一个函数f：：a->b，然后您可以执行此操作来提升该函数以作用于包装的值：

fmap :: (a -> b) -> (Wrapped a -> Wrapped b)
fmap f (Wrap x) = Wrap (f x)

这就是所有需要理解的。然而，事实证明，有一个更通用的函数来执行此提升，即bind：

bind :: (a -> Wrapped b) -> (Wrapped a -> Wrapped b)
bind f (Wrap x) = f x

bind可以比fmap做得更多，但反之亦然。实际上，fmap只能用绑定和返回来定义。因此，在定义monad时。。您给出它的类型（这里是Wrapped a），然后说明它的返回和绑定操作是如何工作的。

很酷的是，这是一个普遍的模式，它会在所有地方弹出，以纯方式封装状态只是其中之一。

有关如何使用monad来引入函数依赖关系，从而控制求值顺序（如Haskell的IO monad中所用）的好文章，请查看IOInside。

至于理解单子，不要太担心。读一些你觉得有趣的东西，如果你不马上理解，也不要担心。那就用Haskell这样的语言潜水吧。修道院就是这样一种东西，在那里，通过练习，理解慢慢地进入你的大脑，有一天你突然意识到你理解了它们。