在最近简要回顾了Haskell之后，对于monad本质上是什么，有什么简单、简洁、实用的解释？
我发现，我遇到的大多数解释都很难理解，而且缺乏实际细节。
当前回答
一个非常简单的答案是：
Monad是一种抽象，它为封装值、计算新的封装值和展开封装值提供了接口。
它们在实践中的方便之处在于，它们提供了一个统一的接口，用于创建建模状态而非状态的数据类型。
必须理解Monad是一种抽象，即用于处理某种数据结构的抽象接口。然后，该接口用于构建具有一元行为的数据类型。
你可以在Ruby中的Monads中找到一个非常好且实用的介绍，第1部分：简介。
其他回答
我也在努力理解单子。这是我的版本：
Monad是关于对重复的事物进行抽象的。首先，monad本身是一个类型化接口（像抽象泛型类），它有两个函数：bind和return，它们定义了签名。然后，我们可以基于抽象的monad创建具体的monad，当然还有绑定和返回的具体实现。此外，绑定和返回必须满足几个不变量，以便可以组合/链接具体的单体。
当我们有接口、类型、类和其他工具来创建抽象时，为什么要创建monad概念？因为monad提供了更多：它们以一种能够在没有任何样板的情况下合成数据的方式强制重新思考问题。
（另请参见“什么是monad？”中的答案）
蒙纳斯的一个很好的动机是西格菲（丹·皮波尼）的《你本可以发明蒙纳斯！（也许你已经有了）。还有很多其他monad教程，其中许多都试图使用各种类比以“简单的术语”来解释monad：这就是monad教程谬论；避开它们。
正如MacIver博士在《告诉我们为什么你的语言很糟糕》中所说：所以，我讨厌Haskell的事情：让我们从显而易见的开始。Monad教程。不，不是单子。特别是教程。他们没完没了，夸夸其谈，亲爱的上帝，他们太乏味了。此外，我从未见过任何令人信服的证据表明它们确实有帮助。阅读类定义，编写一些代码，忘掉这个可怕的名字。
你说你懂“也许莫纳德”吗？很好，你在路上了。只要开始使用其他monad，迟早你会了解monad的一般含义。
（如果你以数学为导向，你可能想忽略几十个教程，学习定义，或遵循类别理论的讲座：）定义的主要部分是Monad M包含一个“类型构造器”，为每个现有类型“T”定义一个新类型“M T”，以及在“常规”类型和“M”类型之间来回移动的一些方式。]
同样，令人惊讶的是，对monad最好的介绍之一实际上是介绍monad的早期学术论文之一，Philip Wadler的Monad for functional programming。它实际上有一些实用的、非平凡的激励性例子，与许多人工教程不同。
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概念的普遍性，这是因为范畴理论非常抽象，所以它的概念对编程非常有用。因此，我们在下面介绍的单子的推广也与范畴理论有着密切的联系，这一点不足为奇。但我们强调，我们的目的非常实用：它不是“实现范畴理论”，而是找到一种更通用的方法来构造组合子库。数学家已经为我们做了很多工作，这是我们的幸运！
从约翰·休斯的《概括单子到箭头》
我最喜欢的Monad教程：
http://www.haskell.org/haskellwiki/All_About_Monads
（在谷歌搜索“monad教程”的17万次点击中！）
@斯图：monads的目的是允许您将（通常）顺序语义添加到纯代码中；您甚至可以组合Monad（使用Monad Transformers）并获得更有趣和复杂的组合语义，例如，带有错误处理的解析、共享状态和日志记录。所有这些在纯代码中都是可能的，monad只允许您将其抽象并在模块化库中重用（在编程中总是很好的），并提供方便的语法使其看起来势在必行。
Haskell已经有了运算符重载[1]：它使用类型类的方式与使用Java或C#中的接口的方式非常相似，但Haskell恰好也允许使用非字母数字标记（如+&&和>）作为中缀标识符。如果您的意思是“重载分号”[2]，那么在您看来这只是运算符重载。“重载分号”听起来像是黑魔法，自找麻烦（想象一下有进取心的Perl黑客听到了这个想法），但关键是没有monad就没有分号，因为纯函数代码不需要或不允许显式排序。
这一切听起来比实际情况要复杂得多。sigfpe的文章很酷，但使用了Haskell来解释它，这有点无法打破理解Haskell到grok Monads和理解Monads到grok Haskell的鸡和蛋的问题。
[1] 这是与monad不同的问题，但monad使用Haskell的运算符重载特性。
[2] 这也是一个过度简化，因为链接一元操作的运算符是>>=（发音为“bind”），但有语法糖（“do”）允许您使用大括号和分号和/或缩进和换行。
