单子的作用基本上是将函数组合在一个链中。时期。

现在，它们的组合方式在现有的单子中有所不同，从而导致了不同的行为(例如，在状态单子中模拟可变状态)。

关于单子的困惑是，它是一种组合函数的机制，可以用于很多事情，因此导致人们相信单子是关于状态，关于IO等，而实际上它们只是关于“组合函数”。

Now, one interesting thing about monads, is that the result of the composition is always of type "M a", that is, a value inside an envelope tagged with "M". This feature happens to be really nice to implement, for example, a clear separation between pure from impure code: declare all impure actions as functions of type "IO a" and provide no function, when defining the IO monad, to take out the "a" value from inside the "IO a". The result is that no function can be pure and at the same time take out a value from an "IO a", because there is no way to take such value while staying pure (the function must be inside the "IO" monad to use such value). (NOTE: well, nothing is perfect, so the "IO straitjacket" can be broken using "unsafePerformIO : IO a -> a" thus polluting what was supposed to be a pure function, but this should be used very sparingly and when you really know to be not introducing any impure code with side-effects.

单子的作用基本上是将函数组合在一个链中。时期。

现在，它们的组合方式在现有的单子中有所不同，从而导致了不同的行为(例如，在状态单子中模拟可变状态)。

关于单子的困惑是，它是一种组合函数的机制，可以用于很多事情，因此导致人们相信单子是关于状态，关于IO等，而实际上它们只是关于“组合函数”。

Now, one interesting thing about monads, is that the result of the composition is always of type "M a", that is, a value inside an envelope tagged with "M". This feature happens to be really nice to implement, for example, a clear separation between pure from impure code: declare all impure actions as functions of type "IO a" and provide no function, when defining the IO monad, to take out the "a" value from inside the "IO a". The result is that no function can be pure and at the same time take out a value from an "IO a", because there is no way to take such value while staying pure (the function must be inside the "IO" monad to use such value). (NOTE: well, nothing is perfect, so the "IO straitjacket" can be broken using "unsafePerformIO : IO a -> a" thus polluting what was supposed to be a pure function, but this should be used very sparingly and when you really know to be not introducing any impure code with side-effects.

Monads are just a convenient framework for solving a class of recurring problems. First, monads must be functors (i.e. must support mapping without looking at the elements (or their type)), they must also bring a binding (or chaining) operation and a way to create a monadic value from an element type (return). Finally, bind and return must satisfy two equations (left and right identities), also called the monad laws. (Alternatively one could define monads to have a flattening operation instead of binding.)

列表单子通常用于处理不确定性。绑定操作选择列表中的一个元素(直观地说，它们都在并行世界中)，让程序员对它们进行一些计算，然后将所有世界中的结果组合到一个列表中(通过连接或平铺嵌套列表)。下面是如何在Haskell的单元框架中定义一个排列函数:

perm [e] = [[e]]
perm l = do (leader, index) <- zip l [0 :: Int ..]
            let shortened = take index l ++ drop (index + 1) l
            trailer <- perm shortened
            return (leader : trailer)

下面是一个示例repl会话:

*Main> perm "a"
["a"]
*Main> perm "ab"
["ab","ba"]
*Main> perm ""
[]
*Main> perm "abc"
["abc","acb","bac","bca","cab","cba"]

需要注意的是，列表单子绝不是计算的副作用。一个数学结构是一个单子(即符合上面提到的接口和规律)并不意味着副作用，尽管副作用现象通常很好地适合单子框架。

如果你有一个类型构造函数和返回该类型族值的函数，你就需要单子。最终，你会想把这些函数组合在一起。这是回答为什么的三个关键要素。

让我详细说明一下。你有Int, String和Real和函数类型Int -> String, String -> Real等等。你可以很容易地组合这些函数，以Int -> Real结尾。生活是美好的。

然后，有一天，您需要创建一个新的类型家族。这可能是因为您需要考虑不返回值(Maybe)、返回错误(Either)、多个结果(List)等的可能性。

注意Maybe是一个类型构造函数。它接受一个类型，比如Int，然后返回一个新的类型，可能是Int。首先要记住，没有类型构造函数，没有单子。

当然，你想在你的代码中使用你的类型构造函数，很快你就会以像Int -> Maybe String和String -> Maybe Float这样的函数结束。现在，你不能轻易地组合你的功能。生活不再美好。

这时单子就来拯救我们了。它们允许你再次组合这类功能。你只需要改变成分。> = =。

我不认为IO应该被视为一个特别出色的单子，但它肯定是一个更令人震惊的初学者，所以我将用它来解释。

Naïvely为Haskell构建IO系统

对于纯函数式语言来说，最简单的IO系统(实际上也是Haskell最初使用的IO系统)是:

main₀ :: String -> String
main₀ _ = "Hello World"

在懒惰的情况下，这个简单的签名就足以实际构建交互式终端程序了——但是非常有限。最令人沮丧的是我们只能输出文本。如果我们增加一些更令人兴奋的输出可能性呢?

data Output = TxtOutput String
            | Beep Frequency

main₁ :: String -> [Output]
main₁ _ = [ TxtOutput "Hello World"
          -- , Beep 440  -- for debugging
          ]

很可爱，但当然，更现实的“替代输出”将写入文件。但是你也需要某种方法从文件中读取。任何机会吗?

当我们使用main₁程序并简单地将文件输送到流程(使用操作系统设施)时，我们实际上已经实现了文件读取。如果我们可以从Haskell语言中触发文件读取…

readFile :: Filepath -> (String -> [Output]) -> [Output]

这将使用一个“交互式程序”String->[Output]，给它一个从文件中获得的字符串，并产生一个简单地执行给定的非交互式程序。

这里有一个问题:我们实际上不知道文件何时被读取。[Output]列表确实给出了一个很好的输出顺序，但我们没有得到输入何时完成的顺序。

解决方案:让输入事件也成为要做的事情列表中的项目。

data IO₀ = TxtOut String
         | TxtIn (String -> [Output])
         | FileWrite FilePath String
         | FileRead FilePath (String -> [Output])
         | Beep Double

main₂ :: String -> [IO₀]
main₂ _ = [ FileRead "/dev/null" $ \_ ->
             [TxtOutput "Hello World"]
          ]

好吧，现在你可能发现了一个不平衡:你可以读取一个文件并依赖于它输出，但你不能使用文件内容来决定是否也读取另一个文件。显而易见的解决方案:使输入事件的结果也是IO类型，而不仅仅是Output类型。这当然包括简单的文本输出，但也允许读取额外的文件等。

data IO₁ = TxtOut String
         | TxtIn (String -> [IO₁])
         | FileWrite FilePath String
         | FileRead FilePath (String -> [IO₁])
         | Beep Double

main₃ :: String -> [IO₁]
main₃ _ = [ TxtIn $ \_ ->
             [TxtOut "Hello World"]
          ]

这实际上允许你在程序中表达任何你想要的文件操作(虽然可能性能不太好)，但这有点过于复杂:

Main₃可以分解出一系列的动作。为什么我们不简单地使用签名::IO₁，它有一个特例? 这些列表不再真正给出程序流程的可靠概述:大多数后续计算只会作为某些输入操作的结果被“宣布”。因此，我们不妨放弃列表结构，并简单地为每个输出操作添加一个“and then do”。

data IO₂ = TxtOut String IO₂
         | TxtIn (String -> IO₂)
         | Terminate

main₄ :: IO₂
main₄ = TxtIn $ \_ ->
         TxtOut "Hello World"
          Terminate

还不错!

那么这一切与单子有什么关系呢?

在实践中，您不希望使用普通构造函数来定义所有程序。需要有几个这样的基本构造函数，但对于大多数更高级别的东西，我们希望编写一个具有一些不错的高级签名的函数。事实证明，其中大多数看起来非常相似:接受某种有意义类型的值，并产生一个IO操作作为结果。

getTime :: (UTCTime -> IO₂) -> IO₂
randomRIO :: Random r => (r,r) -> (r -> IO₂) -> IO₂
findFile :: RegEx -> (Maybe FilePath -> IO₂) -> IO₂

这里显然有一个模式，我们最好这样写

type IO₃ a = (a -> IO₂) -> IO₂    -- If this reminds you of continuation-passing
                                  -- style, you're right.

getTime :: IO₃ UTCTime
randomRIO :: Random r => (r,r) -> IO₃ r
findFile :: RegEx -> IO₃ (Maybe FilePath)

Now that starts to look familiar, but we're still only dealing with thinly-disguised plain functions under the hood, and that's risky: each “value-action” has the responsibility of actually passing on the resulting action of any contained function (else the control flow of the entire program is easily disrupted by one ill-behaved action in the middle). We'd better make that requirement explicit. Well, it turns out those are the monad laws, though I'm not sure we can really formulate them without the standard bind/join operators.

无论如何，我们现在已经达到了一个IO的公式，它有一个合适的单子实例:

data IO₄ a = TxtOut String (IO₄ a)
           | TxtIn (String -> IO₄ a)
           | TerminateWith a

txtOut :: String -> IO₄ ()
txtOut s = TxtOut s $ TerminateWith ()

txtIn :: IO₄ String
txtIn = TxtIn $ TerminateWith

instance Functor IO₄ where
  fmap f (TerminateWith a) = TerminateWith $ f a
  fmap f (TxtIn g) = TxtIn $ fmap f . g
  fmap f (TxtOut s c) = TxtOut s $ fmap f c

instance Applicative IO₄ where
  pure = TerminateWith
  (<*>) = ap

instance Monad IO₄ where
  TerminateWith x >>= f = f x
  TxtOut s c >>= f = TxtOut s $ c >>= f
  TxtIn g >>= f = TxtIn $ (>>=f) . g

显然，这不是一个有效的IO实现，但原则上是可用的。

本杰明·皮尔斯在TAPL中说

一个类型系统可以看作是计算一种静态 近似于程序中项的运行时行为。

这就是为什么配备了强大类型系统的语言严格来说比类型差的语言更具表现力。你可以用同样的方式来思考单子。

正如@Carl和sigfpe所指出的那样，你可以为一个数据类型配备你想要的所有操作，而无需求助于单子、类型类或任何其他抽象的东西。然而，单子不仅允许你编写可重用的代码，还可以抽象出所有冗余的细节。

举个例子，假设我们想过滤一个列表。最简单的方法是使用filter函数:filter (> 3) [1..]10]，等于[4,5,6,7,8,9,10]。

filter的一个稍微复杂一点的版本也是从左向右传递累加器

swap (x, y) = (y, x)
(.*) = (.) . (.)

filterAccum :: (a -> b -> (Bool, a)) -> a -> [b] -> [b]
filterAccum f a xs = [x | (x, True) <- zip xs $ snd $ mapAccumL (swap .* f) a xs]

获取所有i，使i <= 10, sum [1..]I] > 4, sum [1..I] < 25，我们可以写

filterAccum (\a x -> let a' = a + x in (a' > 4 && a' < 25, a')) 0 [1..10]

等于[3,4,5,6]。

或者我们可以重新定义nub函数，它从列表中删除重复的元素，使用filterAccum:

nub' = filterAccum (\a x -> (x `notElem` a, x:a)) []

nub' [1,2,4,5,4,3,1,8,9,4] equals [1,2,4,5,3,8,9]. A list is passed as an accumulator here. The code works, because it's possible to leave the list monad, so the whole computation stays pure (notElem doesn't use >>= actually, but it could). However it's not possible to safely leave the IO monad (i.e. you cannot execute an IO action and return a pure value — the value always will be wrapped in the IO monad). Another example is mutable arrays: after you have leaved the ST monad, where a mutable array live, you cannot update the array in constant time anymore. So we need a monadic filtering from the Control.Monad module:

filterM          :: (Monad m) => (a -> m Bool) -> [a] -> m [a]
filterM _ []     =  return []
filterM p (x:xs) =  do
   flg <- p x
   ys  <- filterM p xs
   return (if flg then x:ys else ys)

filterM对列表中的所有元素执行一个单体操作，生成元素，单体操作返回True。

一个带有数组的过滤示例:

nub' xs = runST $ do
        arr <- newArray (1, 9) True :: ST s (STUArray s Int Bool)
        let p i = readArray arr i <* writeArray arr i False
        filterM p xs

main = print $ nub' [1,2,4,5,4,3,1,8,9,4]

按预期打印[1,2,4,5,3,8,9]。

还有一个带有IO单子的版本，它询问要返回哪些元素:

main = filterM p [1,2,4,5] >>= print where
    p i = putStrLn ("return " ++ show i ++ "?") *> readLn

E.g.

return 1? -- output
True      -- input
return 2?
False
return 4?
False
return 5?
True
[1,5]     -- output

最后一个例子，filterAccum可以用filterM来定义:

filterAccum f a xs = evalState (filterM (state . flip f) xs) a

StateT单子，它在底层使用，只是一个普通的数据类型。

这个例子说明，单子不仅允许您抽象计算上下文和编写干净的可重用代码(由于单子的可组合性，正如@Carl解释的那样)，而且还可以统一对待用户定义的数据类型和内置原语。