这里有一个简单的Monads解释和Marvel的案例研究。

单子是用于对有效的依赖函数进行排序的抽象。这里的有效意味着它们以F[a]的形式返回一个类型，例如Option[a]，其中Option是F，称为类型构造函数。让我们通过两个简单步骤来了解这一点

下面的函数组合是可传递的。所以从A到C，我可以组成A=>B和B=>C。

 A => C   =   A => B  andThen  B => C

然而，如果函数返回一个像Option[A]这样的效果类型，即A=>F[B]，则合成不起作用，因为我们需要A=>B，但我们有A=>F[B]。我们需要一个特殊的运算符“bind”，它知道如何融合这些返回F[a]的函数。

 A => F[C]   =   A => F[B]  bind  B => F[C]

“bind”函数是为特定的F定义的。

对于任何A，也有“return”，类型A=>F[A]，也为特定的F定义。要成为Monad，F必须定义这两个函数。

因此，我们可以从任何纯函数A=>B构造有效函数A=>F[B]，

 A => F[B]   =   A => B  andThen  return

但给定的F也可以定义自己不透明的“内置”特殊函数，这些函数的类型是用户无法自行定义的（纯语言），例如

“随机”（范围=>随机[Int]）“print”（字符串=>IO[（）]）“尝试…捕捉”等。

在OO术语中，monad是一个流畅的容器。

最低要求是类＜a＞的定义，它支持构造函数Something（a a）和至少一个方法Something<B＞flatMap（函数＜a，Something<B＞＞）

可以说，monad类是否有签名Something＜B＞work（）的方法来保存类的规则——编译器在编译时在flatMap中烘焙。

为什么单子有用？因为它是一个允许保留语义的可链式操作的容器。例如，可选<？>为Optional<String>、Optional<Integer>、Optional<MyClass>等保留isPresent的语义。

作为一个粗略的例子，

Something<Integer> i = new Something("a")
  .flatMap(doOneThing)
  .flatMap(doAnother)
  .flatMap(toInt)

注意，我们以字符串开头，以整数结尾。很酷。

在OO中，这可能需要一点努力，但Something上的任何方法如果返回Something的另一个子类，都符合返回原始类型容器的容器函数的标准。

这就是保持语义的方式——即容器的含义和操作不会改变，它们只是包装和增强容器内的对象。

按照OOP程序员将理解（没有任何功能编程背景），什么是莫纳德？它解决了什么问题是最常用的地方吗？是最常用的地方吗？

就OO编程而言，monad是一个接口（或者更可能是一个mixin），由一个类型参数化，具有两个方法，return和bind，它们描述：

如何注入值以获得注入值的一元值类型如何使用从非一元值。

它解决的问题与您期望的任何接口的问题类型相同，“我有很多不同的类，它们做不同的事情，但似乎以一种具有潜在相似性的方式来做这些不同的事情。即使这些类本身不是比‘Object’类本身更接近的子类，我如何描述它们之间的相似性？”

更具体地说，Monad“接口”与IEnumerator或IIterator相似，因为它采用的类型本身也采用的类型。然而，Monad的主要“点”是能够连接基于内部类型的操作，甚至可以连接到具有新的“内部类型”的点，同时保持-甚至增强-主类的信息结构。

我能想到的最简单的解释是，单声道是一种用符号化结果组成函数的方式（也称为克莱斯利合成）。“embelished”函数具有签名a->（b，smth），其中a和b是可能彼此不同但不一定不同的类型（想想Int，Bool），smth是“上下文”或“embelisement”。

这种类型的函数也可以写成a->m b，其中m相当于“embelisation”smth。因此，这些是在上下文中返回值的函数（想想记录其操作的函数，其中smth是日志消息；或者执行输入/输出的函数，其结果取决于IO操作的结果）。

monad是一个接口（“typeclass”），它让实现者告诉它如何组合这样的函数。实现者需要为任何想要实现接口的m类型定义一个组合函数（a->mb）->（b->mc）->（a->mc）（这是Kleisli组合）。

所以，如果我们说我们有一个元组类型（Int，String），它表示Int上的计算结果，（_，String）是“embelisation”-动作的日志-和两个函数increment：：Int->（Int，String）和twoTimes:：Int->（Int、String），我们希望获得一个函数incamentThenDouble:：Int-＞（Int），这是两个函数的组合，也考虑了日志。

在给定的示例中，两个函数的monad实现应用于整数值2增量ThenDouble 2（等于2倍（增量2））将返回（6，“加法1”。中间结果的增量2等于（3，“加1”），2乘以3等于（6，“加3”）

从这个Kleisli合成函数可以导出通常的一元函数。

为了尊重快速阅读者，我首先从精确的定义开始，继续快速的“简单的英语”解释，然后转到示例。

这里有一个简洁而精确的定义，稍微改写了一下：

monad（在计算机科学中）是一个正式的地图，它：将某些给定编程语言的每个类型X发送到一个新的类型T（X）（称为“值为X的T计算类型”）；配备有一个规则，用于组合表单的两个功能f： X->T（Y）和g:Y->T（Z）到函数g∘f:X->T；以一种在明显意义上是关联的并且与称为pure_X:X->T（X）的给定单位函数是单位的方式，可以被认为是将一个值带到纯计算，而纯计算只是返回该值。

因此，简单地说，monad是从任何类型X传递到另一类型T（X）的规则，也是从两个函数f:X->T（Y）和g:Y->T（Z）（您想合成但不能合成）传递到新函数h:X->T（Z）的规则。然而，这并不是严格数学意义上的作文。我们基本上是在“弯曲”函数的组成或重新定义函数的组成方式。

此外，我们需要monad的合成规则来满足“显而易见”的数学公理：

联想性：先用g合成f，然后用h（从外部）合成，应该与先用h合成g，然后用f（从内部）合成相同。酉性质：用任意一侧的单位函数合成f应得到f。

同样，简单地说，我们不能随心所欲地重新定义函数组合：

我们首先需要关联性，以便能够在一行中组合多个函数，例如f（g（h（k（x））），而不用担心指定组合函数对的顺序。由于monad规则只规定了如何组成一对函数，如果没有这个公理，我们需要知道哪个函数对是首先组成的，依此类推。第二，我们需要单位性质，也就是简单地说，恒等式以我们期望的方式构成。因此，只要可以提取这些标识，我们就可以安全地重构函数。

简单地说：monad是类型扩展和组合函数的规则，满足两个公理——结合性和单位性质。

实际上，您希望monad由负责编写函数的语言、编译器或框架为您实现。因此，您可以专注于编写函数的逻辑，而不用担心它们的执行是如何实现的。

简而言之，这就是它的本质。

---

作为一名职业数学家，我倾向于避免将h称为f和g的“组合”，因为在数学上，它不是。将其称为“组成”错误地假定h是真正的数学组成，但它不是。它甚至不是由f和g唯一决定的，而是我们的monad新的“组成函数的规则”的结果。这可能与实际的数学组成完全不同，即使后者存在！

---

为了使它不那么干燥，让我试着用例子来说明我正在用小部分进行注释，因此您可以直接跳到要点。

作为Monad示例引发异常

假设我们要组成两个函数：

f: x -> 1 / x
g: y -> 2 * y

但未定义f（0），因此引发异常e。那么如何定义组成值g（f（0））？当然，再次抛出异常！可能是相同的e.可能是新更新的异常e1。

这里到底发生了什么？首先，我们需要新的异常值（不同或相同）。你可以称它们为nothing或null或其他任何东西，但本质保持不变——它们应该是新的值，例如，在我们这里的示例中，它不应该是数字。我宁愿不将它们称为null，以避免混淆null如何在任何特定语言中实现。同样，我更倾向于避免任何事情，因为它经常与null联系在一起，原则上，这是null应该做的，然而，无论出于什么实际原因，这个原则经常会被扭曲。

例外到底是什么？

这对任何有经验的程序员来说都是一件小事，但我想说几句话来消除任何困惑：

异常是一个封装有关执行的无效结果如何发生的信息的对象。

这可以包括丢弃任何细节并返回单个全局值（如NaN或null），或者生成一个长日志列表或发生了什么，将其发送到数据库并在分布式数据存储层上进行复制；）

这两种极端例外情况之间的重要区别在于，在第一种情况下，没有副作用。第二个是。这就引出了（千美元）问题：

纯函数中是否允许异常？

简短的回答：是的，但前提是它们不会导致副作用。

更长的答案。为了保持纯粹，函数的输出必须由其输入唯一确定。因此，我们通过将0发送到我们称为异常的新抽象值e来修改函数f。我们确保值e不包含外部信息，这些信息不是由我们的输入（即x）唯一确定的。因此，这里是一个没有副作用的异常示例：

e = {
  type: error, 
  message: 'I got error trying to divide 1 by 0'
}

这里有一个副作用：

e = {
  type: error, 
  message: 'Our committee to decide what is 1/0 is currently away'
}

事实上，只有当这种信息在未来可能改变时，它才会产生副作用。但如果它被保证永远不会改变，那么这个值就会变得唯一可预测，因此不会有副作用。

让它更傻。返回42的函数显然是纯的。但如果有人疯狂地决定将42作为一个变量，这个值可能会改变，那么在新的条件下，同样的函数就不再是纯函数。

注意，为了简单起见，我使用了对象文字符号来演示其本质。不幸的是，在JavaScript这样的语言中，错误并不是一种我们想要的函数组合方式，而像null或NaN这样的实际类型并不是这种方式，而是经过一些人工的、不总是直观的类型转换。

类型扩展名

当我们想要改变异常内部的消息时，我们实际上是在为整个异常对象声明一个新的类型E，然后这就是may数的作用，除了它令人困惑的名称，它要么是类型number，要么是新的异常类型E，所以它实际上是number和E的并数|E。特别是，它取决于我们想要如何构造E，这既不是建议的，也不是反映在名称may数中。

什么是功能成分？

这是取函数的数学运算f： X->Y和g:Y->Z和构造它们的组成作为满足h（X）=g（f（X））的函数h:X->Z。当结果f（x）不允许作为g的参数时，就会出现这个定义的问题。

在数学中，没有额外的工作，这些函数是无法合成的。对于我们上面的f和g的例子，严格的数学解决方案是从f的定义集合中删除0。有了新的定义集合（新的更严格的x类型），f变得可以与g组合。

然而，在编程中这样限制f的定义集是不太实际的。相反，可以使用异常。

或者作为另一种方法，人工值被创建为NaN、undefined、null、Infinity等。因此，您可以计算1/0到Infinity和1/-0到Infinity。然后将新值强制返回到表达式中，而不是引发异常。导致您可能会或可能无法预测的结果：

1/0                // => Infinity
parseInt(Infinity) // => NaN
NaN < 0            // => false
false + 1          // => 1

我们又回到了常规数字，准备继续前进；）

JavaScript允许我们以任何代价继续执行数值表达式，而不会像上面的示例那样抛出错误。这意味着，它还允许组合函数。这正是monad的意义所在——这是一条规则，可以组成满足本答案开头定义的公理的函数。

但是，由JavaScript处理数字错误的实现所产生的组成函数的规则是一个monad吗？

要回答这个问题，你只需要检查公理（这里作为练习而不是问题的一部分；）。

抛出异常可以用于构造monad吗？

事实上，一个更有用的monad应该是规定如果f对某个x抛出异常，那么它与任何g的组合也是如此。Plus使异常E全局唯一，只有一个可能的值（范畴理论中的终端对象）。现在这两个公理可以立即检查，我们得到了一个非常有用的monad。其结果就是众所周知的可能是莫纳德。

monad在OO中是否具有“自然”解释取决于monad。在像Java这样的语言中，您可以将may monad转换为检查空指针的语言，这样失败的计算（即，在Haskell中生成Nothing）会将空指针作为结果发出。您可以将状态monad转换为通过创建可变变量和更改其状态的方法生成的语言。

monad是内函子范畴中的幺半群。

这句话所表达的信息非常深刻。你在一个monad中使用任何命令式语言。monad是一种“有序”的领域特定语言。它满足某些有趣的财产，这些属性使单子函数成为“命令式编程”的数学模型。Haskell使定义小型（或大型）命令式语言变得容易，这些语言可以以多种方式组合。

作为一名OO程序员，您使用语言的类层次结构来组织可以在上下文中调用的函数或过程的类型，即您所称的对象。monad也是对这个概念的抽象，因为不同的monad可以以任意方式组合，有效地将所有子monad的方法“导入”到范围中。

从体系结构上讲，然后使用类型签名来明确表示可以使用哪些上下文来计算值。

可以使用monad转换器来实现这一目的，并且有一个高质量的所有“标准”monad集合：

列表（通过将列表视为域进行非确定性计算）可能（计算可能失败，但报告不重要）错误（可能失败并需要异常处理的计算Reader（可以由普通Haskell函数组合表示的计算）编写器（使用顺序“渲染”/“记录”（到字符串、html等）进行计算）续（续）IO（取决于底层计算机系统的计算）状态（上下文包含可修改值的计算）

具有相应的monad变压器和类型类别。类型类允许通过统一monad的接口来组合monad，从而使具体monad可以实现monad“类”的标准接口。例如，模块Control.Monad.State包含一个类MonadState s m，（State s）是表单的一个实例

instance MonadState s (State s) where
    put = ...
    get = ...

长话短说，monad是一个函子，它将“上下文”附加到一个值上，它可以向monad中注入一个值，并且可以根据附加到它上的上下文来评估值，至少是以受限的方式。

So:

return :: a -> m a

是一个函数，它将a类型的值注入到m类型的monad“action”中。

(>>=) :: m a -> (a -> m b) -> m b

是一个执行monad操作、评估其结果并将函数应用于结果的函数。（>>=）的妙处在于结果在同一个monad中。换句话说，在m>>=f中，（>>=）从m中提取结果，并将其绑定到f，这样结果就在monad中。（或者，我们可以说（>>=）将f拉入m，并将其应用于结果。）因此，如果我们有f:：a->m b和g:：b->m c，我们可以“排序”动作：

m >>= f >>= g

或者，使用“do符号”

do x <- m
   y <- f x
   g y

（>>）的类型可能是发光的。它是

(>>) :: m a -> m b -> m b

它对应于C等过程语言中的（；）运算符。它允许使用以下表示法：

m = do x <- someQuery
       someAction x
       theNextAction
       andSoOn

在数学和哲学逻辑中，我们有框架和模型，这些框架和模型“自然”地用单子主义建模。解释是一种函数，它查看模型的域，并计算命题（或公式，在推广下）的真值（或推广）。在必要性的模态逻辑中，我们可能会说，如果命题在“每个可能的世界”中都是真的，那么它是必要的——如果它在每个可容许的域中都是真实的。这意味着命题语言中的模型可以具体化为一个模型，其域由不同模型的集合组成（一个对应于每个可能的世界）。每个monad都有一个名为“join”的方法，该方法将分层，这意味着结果为monad动作的每个monad动作都可以嵌入到monad中。

join :: m (m a) -> m a

更重要的是，这意味着monad在“层堆叠”操作下关闭。这就是monad转换器的工作原理：它们通过为以下类型提供“类联接”方法来组合monad：

newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) }

这样我们就可以将（MaybeT m）中的作用转换为m中的作用，有效地折叠层。在本例中，runMaybeT：：MaybeT m a->m（Maybe a）是我们的类联接方法。（MaybeT m）是一个monad，MaybeT：：m（Maybe a）->MaybeT ma实际上是m中一个新类型monad动作的构造函数。

函子的自由单元是通过堆叠f生成的单元，这意味着f的每个构造函数序列都是自由单元的元素（或者更确切地说，是与f的构造函数序列树形状相同的元素）。自由单体是一种用最少的锅炉板构建柔性单体的有用技术。在Haskell程序中，我可能会使用自由monad来为“高级系统编程”定义简单monad，以帮助维护类型安全（我只是在使用类型及其声明。使用组合子可以直接实现）：

data RandomF r a = GetRandom (r -> a) deriving Functor
type Random r a = Free (RandomF r) a


type RandomT m a = Random (m a) (m a) -- model randomness in a monad by computing random monad elements.
getRandom     :: Random r r
runRandomIO   :: Random r a -> IO a (use some kind of IO-based backend to run)
runRandomIO'  :: Random r a -> IO a (use some other kind of IO-based backend)
runRandomList :: Random r a -> [a]  (some kind of list-based backend (for pseudo-randoms))

Monastem是您可能称之为“解释器”或“命令”模式的基础架构，抽象为最清晰的形式，因为每个单元计算都必须“运行”，至少是微不足道的。（运行时系统为我们运行IO monad，是任何Haskell程序的入口点。IO通过按顺序运行IO操作来“驱动”其余的计算）。

join的类型也是我们得到monad是内函子范畴中的幺半群的陈述的地方。由于其类型，联接对于理论目的来说通常更为重要。但了解类型意味着了解单子。Join和monad变换器的类Join类型在函数组合的意义上是内函子的有效组合。把它放在类似Haskell的伪语言中，

Foo:：m（m a）<->（m.m）a