monad是一种具有两个操作的数据类型：>>=（又名bind）和return（又名unit）。return接受一个任意值并用它创建monad的实例。>>=接受monad的一个实例并在其上映射一个函数。（您已经可以看到monad是一种奇怪的数据类型，因为在大多数编程语言中，您无法编写一个接受任意值并从中创建类型的函数。monad使用一种参数多态性。）

在Haskell表示法中，monad接口是

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

这些操作应该遵守某些“法则”，但这并不是非常重要的：“法则”只是将操作的合理实现行为化（基本上，>>=和return应该就如何将值转换为monad实例达成一致，并且>>=是关联的）。

Monad不仅仅是关于状态和I/O：它们抽象了一种常见的计算模式，包括处理状态、I/O、异常和非确定性。可能最容易理解的单子是列表和选项类型：

instance Monad [ ] where
    []     >>= k = []
    (x:xs) >>= k = k x ++ (xs >>= k)
    return x     = [x]

instance Monad Maybe where
    Just x  >>= k = k x
    Nothing >>= k = Nothing
    return x      = Just x

其中[]和：是列表构造函数，++是串联运算符，Just和Nothing是Maybe构造函数。这两个monad都在各自的数据类型上封装了常见的有用的计算模式（请注意，两者都与副作用或I/O无关）。

你真的需要写一些非平凡的Haskell代码来理解monad的含义以及它们为什么有用。

在Scala的上下文中，您会发现以下是最简单的定义。基本上，flatMap（或bind）是“关联”的，并且存在一个标识。

trait M[+A] {
  def flatMap[B](f: A => M[B]): M[B] // AKA bind

  // Pseudo Meta Code
  def isValidMonad: Boolean = {
    // for every parameter the following holds
    def isAssociativeOn[X, Y, Z](x: M[X], f: X => M[Y], g: Y => M[Z]): Boolean =
      x.flatMap(f).flatMap(g) == x.flatMap(f(_).flatMap(g))

    // for every parameter X and x, there exists an id
    // such that the following holds
    def isAnIdentity[X](x: M[X], id: X => M[X]): Boolean =
      x.flatMap(id) == x
  }
}

E.g.

// These could be any functions
val f: Int => Option[String] = number => if (number == 7) Some("hello") else None
val g: String => Option[Double] = string => Some(3.14)

// Observe these are identical. Since Option is a Monad 
// they will always be identical no matter what the functions are
scala> Some(7).flatMap(f).flatMap(g)
res211: Option[Double] = Some(3.14)

scala> Some(7).flatMap(f(_).flatMap(g))
res212: Option[Double] = Some(3.14)


// As Option is a Monad, there exists an identity:
val id: Int => Option[Int] = x => Some(x)

// Observe these are identical
scala> Some(7).flatMap(id)
res213: Option[Int] = Some(7)

scala> Some(7)
res214: Some[Int] = Some(7)

注：严格地说，函数编程中的Monad的定义与范畴理论中的Monard的定义不同，后者是按映射和展平的顺序定义的。尽管它们在某些映射下是等价的。这个演示非常好：http://www.slideshare.net/samthemonad/monad-presentation-scala-as-a-category

但是，你本可以发明蒙纳斯！

sigfpe说：但所有这些都将单子介绍为需要解释的深奥的东西。但我想说的是，它们一点都不深奥。事实上，面对函数式编程中的各种问题，你会不可避免地被引向某些解决方案，所有这些都是单子的例子。事实上，如果你还没有发明，我希望你现在就发明它们。这是注意到所有这些解决方案实际上都是变相的相同解决方案的一小步。读完这篇文章后，你可能会更好地理解单子上的其他文档，因为你会发现你所看到的一切都是你已经发明的。monads试图解决的许多问题都与副作用有关。因此，我们将从它们开始。（请注意，monad让您做的不仅仅是处理副作用，特别是许多类型的容器对象都可以被视为monad。monad的一些介绍发现，很难协调monad的这两种不同用法，并且只关注其中一种。）在命令式编程语言（如C++）中，函数的行为与数学函数完全不同。例如，假设我们有一个C++函数，它接受一个浮点参数并返回一个浮点结果。从表面上看，它可能有点像一个将实数映射到实数的数学函数，但C++函数可以做的不仅仅是返回一个依赖于其参数的数字。它可以读取和写入全局变量的值，也可以将输出写入屏幕并接收用户的输入。然而，在纯函数语言中，函数只能读取在其参数中提供给它的内容，而它对世界产生影响的唯一方式是通过它返回的值。

如果你要求对如此抽象的东西做出简洁、实用的解释，那么你只能希望得到一个抽象的答案：

a -> b

是表示从as到bs的计算的一种方式。您可以将计算链接起来，也可以将它们组合在一起：

(b -> c) -> (a -> b) -> (a -> c)

更复杂的计算需要更复杂的类型，例如：

a -> f b

是从as到bs到fs的计算类型。您还可以编写它们：

(b -> f c) -> (a -> f b) -> (a -> f c)

事实证明，这种模式无处不在，并且与上面的第一个组合具有相同的财产（结合性、右-和左-同一性）。

人们必须给这个模式起一个名字，但如果知道第一个组合被正式描述为半群体，这会有帮助吗？

“单子和圆括号一样有趣和重要”（奥列格·基斯廖夫）

http://code.google.com/p/monad-tutorial/正是为了解决这个问题而进行的工作。

遵循您简短、简洁、实用的指示：

理解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，如果它在上下文中有意义”