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

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

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

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

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

你最近有一篇演讲《Monadologie——关于类型焦虑的专业帮助》（Christopher League，2010年7月12日），这篇演讲对延续和monad的话题非常有趣。这个（幻灯片）演示的视频实际上可以在vimeo上获得。Monad部分开始于37分钟左右，在这段一小时的视频中，从58张幻灯片中的第42张幻灯片开始。

它被称为“函数式编程的主要设计模式”，但示例中使用的语言是Scala，它既是面向对象的又是函数式的。您可以在Debasish Ghosh（2008年3月27日）的博客文章“Monads-在Scala中抽象计算的另一种方法”中阅读更多关于Monad的内容。

如果类型构造函数M支持以下操作，那么它就是monad：

# the return function
def unit[A] (x: A): M[A]

# called "bind" in Haskell 
def flatMap[A,B] (m: M[A]) (f: A => M[B]): M[B]

# Other two can be written in term of the first two:

def map[A,B] (m: M[A]) (f: A => B): M[B] =
  flatMap(m){ x => unit(f(x)) }

def andThen[A,B] (ma: M[A]) (mb: M[B]): M[B] =
  flatMap(ma){ x => mb }

例如（在Scala中）：

选项是monad

    def unit[A] (x: A): Option[A] = Some(x)

    def flatMap[A,B](m:Option[A])(f:A =>Option[B]): Option[B] =
      m match {
       case None => None
       case Some(x) => f(x)
      }

列表为Monad

    def unit[A] (x: A): List[A] = List(x)

    def flatMap[A,B](m:List[A])(f:A =>List[B]): List[B] =
      m match {
        case Nil => Nil
        case x::xs => f(x) ::: flatMap(xs)(f)
      }

Monad在Scala中非常重要，因为它是为了利用Monad结构而构建的方便语法：

对于Scala的理解：

for {
  i <- 1 to 4
  j <- 1 to i
  k <- 1 to j
} yield i*j*k

由编译器翻译为：

(1 to 4).flatMap { i =>
  (1 to i).flatMap { j =>
    (1 to j).map { k =>
      i*j*k }}}

关键抽象是flatMap，它通过链接绑定计算。flatMap的每次调用都返回相同的数据结构类型（但值不同），作为链中下一个命令的输入。

在上面的代码段中，flatMap将闭包（SomeType）=>List[AanotherType]作为输入，并返回List[Aanother Type]。需要注意的一点是，所有flatMap都采用相同的闭包类型作为输入，并返回与输出相同的类型。

这就是“绑定”计算线程的原因——为了理解，序列中的每一项都必须遵守相同的类型约束。

---

如果您执行两个操作（可能失败）并将结果传递给第三个，例如：

lookupVenue: String => Option[Venue]
getLoggedInUser: SessionID => Option[User]
reserveTable: (Venue, User) => Option[ConfNo]

但如果不利用Monad，你会得到复杂的OOP代码，比如：

val user = getLoggedInUser(session)
val confirm =
  if(!user.isDefined) None
  else lookupVenue(name) match {
    case None => None
    case Some(venue) =>
      val confno = reserveTable(venue, user.get)
      if(confno.isDefined)
        mailTo(confno.get, user.get)
      confno
  }

而使用Monad，您可以像所有操作一样使用实际类型（地点、用户），并隐藏选项验证内容，这都是因为for语法的平面图：

val confirm = for {
  venue <- lookupVenue(name)
  user <- getLoggedInUser(session)
  confno <- reserveTable(venue, user)
} yield {
  mailTo(confno, user)
  confno
}

只有当所有三个函数都具有Some[X]时，才会执行屈服部分；任何“无”将直接返回以确认。

---

So:

Monad允许在函数编程中进行有序计算，这允许我们以一种很好的结构化形式（有点像DSL）对动作序列进行建模。最大的能力来自于将服务于不同目的的monad组合成应用程序中的可扩展抽象的能力。monad对动作的排序和线程化由语言编译器完成，该语言编译器通过闭包的魔力进行转换。

---

顺便说一句，Monad不是FP中使用的唯一计算模型：

范畴理论提出了许多计算模型。其中计算的Arrow模型莫纳德计算模型计算的应用模型

在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的另一个子类，都符合返回原始类型容器的容器函数的标准。

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

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

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

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

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

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

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

我想说，与monads最接近的OO类比是“命令模式”。

在命令模式中，将普通语句或表达式包装在命令对象中。命令对象公开执行包装语句的执行方法。所以，语句被转换为可以随意传递和执行的第一类对象。可以组合命令，以便通过链接和嵌套命令对象来创建程序对象。

命令由单独的对象调用程序执行。使用命令模式（而不仅仅是执行一系列普通语句）的好处是，不同的调用程序可以将不同的逻辑应用于如何执行命令。

命令模式可用于添加（或删除）宿主语言不支持的语言功能。例如，在没有异常的假设OO语言中，可以通过向命令公开“try”和“throw”方法来添加异常语义。当命令调用throw时，调用程序会回溯到命令列表（或树），直到最后一次“try”调用。相反，您可以通过捕获每个单独命令抛出的所有异常，并将它们转换为错误代码，然后传递给下一个命令，从而从语言中删除异常语义（如果您认为异常是坏的）。

甚至更花哨的执行语义（如事务、非确定性执行或延续）也可以用本机不支持的语言实现。如果你仔细想想，这是一个非常强大的模式。

实际上，命令模式并没有像这样作为通用语言特性使用。将每个语句转换为单独的类的开销将导致无法忍受的样板代码。但原则上，它可以用于解决与在fp中使用monad解决的问题相同的问题。