回顾之前代码¶

-- file: ch10/PNM.hs
matchHeader :: L.ByteString -> L.ByteString -> Maybe L.ByteString

-- "nat" here is short for "natural number"
getNat :: L.ByteString -> Maybe (Int, L.ByteString)

getBytes :: Int -> L.ByteString
         -> Maybe (L.ByteString, L.ByteString)

    parseP5 s =
      case matchHeader (L8.pack "P5") s of
        Nothing -> Nothing
        Just s1 ->
          case getNat s1 of
            Nothing -> Nothing
            Just (width, s2) ->
              case getNat (L8.dropWhile isSpace s2) of
                Nothing -> Nothing
                Just (height, s3) ->
                  case getNat (L8.dropWhile isSpace s3) of
                    Nothing -> Nothing
                    Just (maxGrey, s4)
                      | maxGrey > 255 -> Nothing
                      | otherwise ->
                          case getBytes 1 s4 of
                            Nothing -> Nothing
                            Just (_, s5) ->
                              case getBytes (width * height) s5 of
                                Nothing -> Nothing
                                Just (bitmap, s6) ->
                                  Just (Greymap width height maxGrey bitmap, s6)

-- file: ch10/PNM.hs
(>>?) :: Maybe a -> (a -> Maybe b) -> Maybe b
Nothing >>? _ = Nothing
Just v  >>? f = f v

-- file: ch10/PNM.hs
parseP5_take2 :: L.ByteString -> Maybe (Greymap, L.ByteString)
parseP5_take2 s =
    matchHeader (L8.pack "P5") s       >>?
    \s -> skipSpace ((), s)           >>?
    (getNat . snd)                    >>?
    skipSpace                         >>?
    \(width, s) ->   getNat s         >>?
    skipSpace                         >>?
    \(height, s) ->  getNat s         >>?
    \(maxGrey, s) -> getBytes 1 s     >>?
    (getBytes (width * height) . snd) >>?
    \(bitmap, s) -> Just (Greymap width height maxGrey bitmap, s)

skipSpace :: (a, L.ByteString) -> Maybe (a, L.ByteString)
skipSpace (a, s) = Just (a, L8.dropWhile isSpace s)

-- file: ch10/Parse.hs
(==>) :: Parse a -> (a -> Parse b) -> Parse b

firstParser ==> secondParser  =  Parse chainedParser
  where chainedParser initState   =
          case runParse firstParser initState of
            Left errMessage ->
                Left errMessage
            Right (firstResult, newState) ->
                runParse (secondParser firstResult) newState

寻找共同特征¶

如果我们仔细分析上面的例子，它们好像没有什么共同特点。不过有一点比较明显，它们都想把函数串联起来并试图隐藏细节以便我们写出整洁的代码。然后，我们先不管那些细节，从更粗略的层面去思考一下。

首先，我们看一看类型声明：

-- file: ch14/Maybe.hs
data Maybe a = Nothing
             | Just a

-- file: ch11/Parse.hs
newtype Parse a = Parse {
      runParse :: ParseState -> Either String (a, ParseState)
    }

这两个类型的共同特点是它们都有一个类型参数，因此它们都是范型，对具体的类型一无所知。

然后看一看我们给两个类型写的串联函数：

ghci> :type (>>?)
(>>?) :: Maybe a -> (a -> Maybe b) -> Maybe b

ghci> :type (==>)
(==>) :: Parse a -> (a -> Parse b) -> Parse b

这两个函数的类型非常相似，如果我们把它们的类型构造器替换为一个类型变量，我们会得到一个更加抽象的类型。

-- file: ch14/Maybe.hs
chain :: m a -> (a -> m b) -> m b

最终，在两种情况下，我们都得到了一个获取一个普通的值，然后把它“注入”到一个目标类型里面去的函数。对于 Maybe 类型，这个函数就是它的一个值构造器 Just ，``Parse``的注入函数就略微复杂一些。

-- file: ch10/Parse.hs
identity :: a -> Parse a
identity a = Parse (\s -> Right (a, s))

我们不用关心它的实现细节，也不管它有多么复杂；重要的是，这些类型都有一个“注入器”函数，它大致长这样：

-- file: ch14/Maybe.hs
inject :: a -> m a

在Haskell里面，正是这三个属性和一些如何使用它们的规则定义了monad。我们集中总结一下：

1. 一个类型构造器 m
2. 一个用于把某个函数的输出串联到另外一个函数输入上的函数，它的类型是 m a -> (a -> m b) -> m b
3. 一个类型是 a -> m a 类型的函数，它把普通值注入到调用链里面，也就是说，它把类型 a 用类型构造器 m 包装起来。

Maybe 类型的类型构造器 Maybe a ,串联函数 (>>?) 以及注入函数 Just 使Maybe成为一个monad。对于 Parse 类型，对应的是类型构造器 Parse a ,串联函数 Parse a 以及注入函数 identify 。

对于Monad的串联函数和注入函数具体应该干什么我们刻意只字未提，因为它几乎不重要。事实上，正是因为Monad如此简单，它在Haskell里面无处不在。许多常见的编程模式都用到了monad结构：传递隐式数据，或是短路求值链。

Monad 类型类¶

在Haskell里面我们可以使用一个类型类(typeclass)来表示“串联”以及“注入”的概念以及它们的类型。标准库的Predule模块已经包含了这样一个类型类，也就是 Monad 。

-- file: ch14/Maybe.hs
class Monad m where
    -- chain
    (>>=)  :: m a -> (a -> m b) -> m b
    -- inject
    return :: a -> m a

在这里，(>>=) 就是我们的串联函数。 在 串联化（Sequencing） 中我们已经介绍了它。通常将这个操作符称呼为“绑定”，因为它把左侧运算的结果绑定到右侧运算的参数上。

我们的注入函数是 return ,在 Return的本色 中讲过，选用 return 这个名字有点倒霉。这个关键字在命令式语言中被广泛使用并且有一个非常容易理解的含义。但是在Haskell里面它的含义完全不同；具体来说，在函数调用链中间使用 return 并不会导致调用链提前中止；我们可以这样理解它：它把纯值( a 类型)放进(returns)monads( m a 类型)里。

(>>=) 和 return 是 Monad 这个类型类的核心函数；除此之外，它还定义了另外两个函数。一个函数是 (>>) ，类似于 (>>=) ，它的作用也是串联，但是它忽略左侧的值。

-- file: ch14/Maybe.hs
    (>>) :: m a -> m b -> m b
        a >> f = a >>= \_ -> f

当我们需要按顺序执行一系列操作的，并且不关心先前的计算结果的时候，可以使用这操作符。这样也许看起来让人觉得费解：为什么我们会忽略一个函数的返回值呢，这样有什么意义？回想一下，我们之前定义了一个 (==>&) 组合子来专门表达这个概念。另外，考虑一下 print 这样的函数，它的返回结果是一个占位符，我们没有必要关心它返回值是什么。

ghci> :type print "foo"
print "foo" :: IO ()

如果我们使用普通的 (>>=) 来串联调用，我们必须提供一个新的函数来忽略参数（这个参数是前一个 print 的返回值。)

ghci> print "foo" >>= \_ -> print "bar"
"foo"
"bar"

但是，如果我们使用 (>>) 操作符，那么就可以去掉那个没什么用的函数了：

ghci> print "baz" >> print "quux"
"baz"
"quux"

正如我们上面看到的一样， (>>) 的默认实现是通过 (>>=) 完成的。

Monad类型类另外一个非核心函数是 fail ,这个函数接受一个错误消息然后让函数调用链失败。

回顾一下我们在 第 10 章：代码案例学习：解析二进制数据格式 写的parse, 里面有一个 Monad 的实例：

-- file: ch10/Parse.hs
instance Monad Parse where
    return = identity
    (>>=) = (==>)
    fail = bail

术语解释¶

可能你对monad的某些惯用语并不熟悉，虽然他们不是正式术语，但是很常见；因此有必要了解一下。

• “Monadic”仅仅表示“和Monad相关的”。一个monadic 类型就是一个Monad 类型类的实例；一个monadic值就是一个具有monadic类型的值。
• 当我们说某个东西“是一个monad”的时候，我们其实表达的意思是“这个类型是Monad这个类型类的实例”；作为Monad的实例就有三要素：类型构造器，注入函数，串联函数。
• 同样，当我们谈到“Foo这个monad”的时候，我们实际上指的是Foo这个类型，只不过Foo是Monad这个类型类的实例。
• Monadic值的一个别称是“动作”；这个说法可能源自 I/O Monad 的引入， print "foo" 这样的monad值会导致副作用。返回类型是monadic值的函数有时候也被称之为动作，虽然这样并不太常见。

使用新的Monad¶

我们在介绍Monad的时候，展示了一些之前的代码，并说明它们其实就是Monad。既然我们慢慢知道monad是什么，而且已经见识过 Monad 这个类型类；现在就让我们用学到的知识来写一个Monad吧。我们先定义它的接口，然后使用它；一旦完成了这些，我们就写出了自己的Monad！

纯粹的Haskell代码写起来非常简洁，但是它不能执行IO操作；有时候，我们想记下我们程序的一些操作，但是又不想直接把日志信息写入文件；就这些需求，我们开发一个小型库。

回忆一下我们在 将 glob 模式翻译为正则表达式 中定义的 globToRegex 函数；我们修改它让它能够记住每次它翻译过的句子。我们又回到了熟悉的恐怖场景：比较同一份代码的Monadic版本和非Monadic版。

首先，我们可以使用一个 Logger 类型类把处理结果的类型包装起来。

-- file: ch14/Logger.hs
globToRegex :: String -> Logger String

-- file: ch14/Logger.hs
module Logger
    (
      Logger
    , Log
    , runLogger
    , record
    ) where

-- file: ch14/Logger.hs
type Log = [String]

-- file: ch14/Logger.hs
runLogger :: Logger a -> (a, Log)

-- file: ch14/Logger.hs
record :: String -> Logger ()

ghci> let simple = return True :: Logger Bool
ghci> runLogger simple
(True,[])

ghci> runLogger (record "hi mom!" >> return 3.1337)
(3.1337,["hi mom!"])

-- file: ch14/Logger.hs
globToRegex cs =
    globToRegex' cs >>= \ds ->
    return ('^':ds)

ghci> :type (>>=)
(>>=) :: (Monad m) => m a -> (a -> m b) -> m b
ghci> :type (globToRegex "" >>=)
(globToRegex "" >>=) :: (String -> Logger b) -> Logger b

-- file: ch14/Logger.hs
globToRegex' :: String -> Logger String
globToRegex' "" = return "$"

-- file: ch14/Logger.hs
globToRegex' ('?':cs) =
    record "any" >>
    globToRegex' cs >>= \ds ->
    return ('.':ds)

-- file: ch14/Logger.hs
globToRegex' ('*':cs) = do
    record "kleene star"
    ds <- globToRegex' cs
    return (".*" ++ ds)

-- file: ch14/Logger.hs
globToRegex' ('[':'!':c:cs) =
    record "character class, negative" >>
    charClass cs >>= \ds ->
    return ("[^" ++ c : ds)
globToRegex' ('[':c:cs) =
    record "character class" >>
    charClass cs >>= \ds ->
    return ("[" ++ c : ds)
globToRegex' ('[':_) =
    fail "unterminated character class"

同时使用puer和monadic代码¶

迄今为止我们看到的Monad好像有一个非常明显的缺陷：Monad的类型构造器把一个值包装成一个monadic的值，这样导致在monad里面使用普通的纯函数有点困难。举个例子，假设我们有一段运行在monad里面的代码，它所做的就是返回一个字符串：

ghci> let m = return "foo" :: Logger String

如果我们想知道字符串的长度是多少，我们不能直接调用 length 函数：因为这个字符串被 Logger 这个monad包装起来了，因此类型并不匹配。

ghci> length m

<interactive>:1:7:
    Couldn't match expected type `[a]'
           against inferred type `Logger String'
    In the first argument of `length', namely `m'
    In the expression: length m
    In the definition of `it': it = length m

我们能做的事情就是下面这样：

ghci> :type   m >>= \s -> return (length s)
m >>= \s -> return (length s) :: Logger Int

我们使用 (>>=) 把字符串从monad里面取出来，然后使用一个匿名函数调用 length 接着用 return 把这个字符串重新包装成 Logger 。

由于这种形式的代码经常在Haskell里面出现，因此已经有一个类似的操作符存在了。在 Functor 简介 里面我们介绍了 lifting 这种技术；把一个纯函数 Lift 为一个函子通常意味着从一个带有上下文的特殊值里面取出那个值，然后使用这个普通的值调用纯函数，得到结果之后用特定的类型构造器包装成原来有着上下文的特殊值。

在monad里面，我们需要干同样的一件事。由于 Monad 这个类型类已经提供了 (>>=) 和 return 这两个函数处理monadic的值和普通值之间的转换，因此 liftM 函数不需要知道monad的任何实现细节。

-- file: ch14/Logger.hs
liftM :: (Monad m) => (a -> b) -> m a -> m b
liftM f m = m >>= \i ->
            return (f i)

当我们把一个类型声明为 Functor 这个类型类的实例之后，我们必须根据这个特定的类型实现对应的 fmap 函数；但是， 由于 (>>=) 和 return 对monad的进行了抽象，因此``liftM`` 不需要知道任何monad的任何实现细节。我们只需要实现一次并配上合适的类型签名即可。

在标准库的 Control.Monad 模块里面已经为我们定义好了 liftM 函数。

我们来看看使用 liftM 对于提升我们代码可读性有什么作用；先看看没有使用 liftM 的代码：

-- file: ch14/Logger.hs
charClass_wordy (']':cs) =
    globToRegex' cs >>= \ds ->
    return (']':ds)
charClass_wordy (c:cs) =
    charClass_wordy cs >>= \ds ->
    return (c:ds)

然后我们用 liftM 去掉那些 (>>=)) 和匿名函数：

-- file: ch14/Logger.hs
charClass (']':cs) = (']':) `liftM` globToRegex' cs
charClass (c:cs) = (c:) `liftM` charClass cs

正如 fmap 一样，我们通常用中缀的方式调用 liftM 。可以用这种方式来阅读这个表达式：把右边操作得到的monadic的值应用到左边的纯函数上。

liftM 函数实在是太有用了，因此 Control.Monad 定义了它的几个变种，这些变种可以处理更长的参数；我们可以看一看 globToRegex 这个函数的最后一个分句：

-- file: ch14/Logger.hs
globToRegex' (c:cs) = liftM2 (++) (escape c) (globToRegex' cs)

escape :: Char -> Logger String
escape c
    | c `elem` regexChars = record "escape" >> return ['\\',c]
    | otherwise           = return [c]
  where regexChars = "\\+()^$.{}]|"

上面这段代码用到的 liftM2 函数的定义如下：

-- file: ch14/Logger.hs
liftM2 :: (Monad m) => (a -> b -> c) -> m a -> m b -> m c
liftM2 f m1 m2 =
    m1 >>= \a ->
    m2 >>= \b ->
    return (f a b)

它首先执行第一个动作，接着执行第二个操作，然后把这两个操作的结果组合起来应用到那个纯函数上并包装返回的结果。 Control.Monad 里面定义了 liftM liftM2 直到 liftM5 。

关于Monad的一些误解¶

我们已经见识过很多Monad的例子并且对monad也有一些感觉了；在继续探讨monad之前，有一些广为流传的关于monad的观念需要澄清。你肯定经常听到这些说法，因此你可能已经有一些很好的理由来反驳这些谬论了。

• Monads很难理解 我们已经从好几个实例的问题来说明Monad是如何工作的了，并且我们已经知道理解monad最好的方式就是先通过一些具体的例子来进行解释，然后抽象出这些这些例子共同的东西。
• Monads仅仅用于 I/O 操作和命令式代码 虽然我们在Haskell的IO里面使用Monad，但是Monad在其他的地方也非常有用。我们已经通过monad串联简单的计算，隐藏复杂的状态以及纪录日志了；然而，Monad的作用我们还只看到冰山一角。
• 只有Haskell才有Monad Haskell有可能是显式使用Monad最多的语言，但是在别的语言里面也存在，从C++到OCaml。由于Haskell的 do 表示法，强大的类型系统以及语言的语法使得Monad在Haskell里面非常容易处理。
• Monads使用来控制求值顺序的

创建Logger Monad¶

Logger 类的定义非常简单：

-- file: ch14/Logger.hs
newtype Logger a = Logger { execLogger :: (a, Log) }

它其实就是一个二元组，第一个元素是执行动作的结果，第二元素是我们执行动作的时候纪录的日志信息列表。

我们使用 newtype 关键字把二元组进行了包装使它的类型更加清晰易读。 runLogger 函数可以从这个Monad里面取出这个元组里面的值；这个函数其实是 execLogger 的一个别名。

-- file: ch14/Logger.hs
runLogger = execLogger

record 这个函数将为接收到的日志信息创建一个只包含单个元素的列表。

-- file: ch14/Logger.hs
record s = Logger ((), [s])

这个动作的结果是 () 。

让我们以 return 开始，构建 Monad 实例；先尝试一下：它什么都不记录，然后把结果存放在二元组里面。

-- file: ch14/Logger.hs
instance Monad Logger where
    return a = Logger (a, [])

(>>=) 的定义更有趣，当然它也是monad的核心。 (>>=) 把一个普通的值和一个monadic的函数结合起来，得到新的运算结果和一个新的日志信息。

-- file: ch14/Logger.hs
    -- (>>=) :: Logger a -> (a -> Logger b) -> Logger b
    m >>= k = let (a, w) = execLogger m
                  n      = k a
                  (b, x) = execLogger n
              in Logger (b, w ++ x)

我们看看这段代码里面发生了什么。首先使用 runLogger 函数从动作 m 取出结果 a ,然后把它传递给monadic函数 k; 接着我们又取出 b ；最后把 w 和 x 拼接得到一个新的日志。

Maybe monad¶

Maybe 应该是最简单的Monad了。它代表了一种可能不会产生计算结果的计算过程。

-- file: ch14/Maybe.hs
instance Monad Maybe where
    Just x >>= k  =  k x
    Nothing >>= _ =  Nothing

    Just _ >> k   =  k
    Nothing >> _  =  Nothing

    return x      =  Just x

    fail _        =  Nothing

当我们使用 (>>=) 或者 (>>) 串联一些 Maybe 计算的时候，如果这些计算中的任何一个返回了 Nothing ， (>>=) 和 (>>) 就不会对余下的任何计算进行求值。

值得一提的是，整个调用链并不是完全短路的。每一个 (>>=) 或者 (>>) 仍然会匹配它左边的 Nothing 然后给右边的函数一个 Nothing, 直到达到调用链的末端。这一点很容易被遗忘：当调用链中某个计算失败的时候，之前计算的结果，余下的调用链以及使用的 Nothing 值在运行时的开销是廉价的，但并不是完全没有开销。

-- file: ch14/Maybe.hs
maybe :: b -> (a -> b) -> Maybe a -> b
maybe n _ Nothing  = n
maybe _ f (Just x) = f x

-- file: ch14/Carrier.hs
import qualified Data.Map as M

type PersonName = String
type PhoneNumber = String
type BillingAddress = String
data MobileCarrier = Honest_Bobs_Phone_Network
                   | Morrisas_Marvelous_Mobiles
                   | Petes_Plutocratic_Phones
                     deriving (Eq, Ord)

findCarrierBillingAddress :: PersonName
                          -> M.Map PersonName PhoneNumber
                          -> M.Map PhoneNumber MobileCarrier
                          -> M.Map MobileCarrier BillingAddress
                          -> Maybe BillingAddress

-- file: ch14/Carrier.hs
variation1 person phoneMap carrierMap addressMap =
    case M.lookup person phoneMap of
      Nothing -> Nothing
      Just number ->
          case M.lookup number carrierMap of
            Nothing -> Nothing
            Just carrier -> M.lookup carrier addressMap

ghci> :module +Data.Map
ghci> :type Data.Map.lookup
Data.Map.lookup :: (Ord k, Monad m) => k -> Map k a -> m a

-- file: ch14/Carrier.hs
variation2 person phoneMap carrierMap addressMap = do
  number <- M.lookup person phoneMap
  carrier <- M.lookup number carrierMap
  address <- M.lookup carrier addressMap
  return address

-- file: ch14/Carrier.hs
variation2a person phoneMap carrierMap addressMap = do
  number <- M.lookup person phoneMap
  carrier <- M.lookup number carrierMap
  M.lookup carrier addressMap

List Monad¶

Maybe 类型代表有可能有值也可能没有值的计算；也有的情况下希望计算会返回一系列的结果，显然，List正适合这个目的。List的类型带有一个参数，这暗示它有可能能作为一个monad使用；事实上，我们确实能把它当作monad使用。

先不看标准库的 Prelude 对于List monad的实现，我们自己来看看一个 List 的monad应该是什么样的。这个过程很简单：首先看 (>>=) 和 return 的类型，然后进行一些替换操作，看看我们能不能使用一些熟悉的list函数。

return 和 (>>=) 这两个函数里面显然 return 比较简单。我们已经知道 return 函数接受一个类型，然后把它用类型构造器 m 包装一下然后产生一个新的类型 m a. 在List这种情况下，这个类型构造器就是 []. 把这个类型构造器使用List的类型构造器替换掉我们就得到了类型 [] a (当然，这样写是非法的！）；可以把它写成更加熟悉的形式 [a].

现在我们知道list的 return 函数的类型应该是 a -> [a] 。对于这种类型的函数，只有少数那么几种实现的可能：要么它返回一个空列表，要么返回一个单个元素的列表，或者一个无穷长度的列表。基于我们现在对于Monad的理解，最有可能的实现方式应该是返回单个元素的列表：它不会丢失已有信息，也不会无限重复。

-- file: ch14/ListMonad.hs
returnSingleton :: a -> [a]
returnSingleton x = [x]

如果我们对 (>>=) 的类型签名进行和 return 类似的替换，我们会得到： [a] -> (a -> [b]) -> [b] . 这看起来和 map 非常相似。

ghci> :type (>>=)
(>>=) :: (Monad m) => m a -> (a -> m b) -> m b
ghci> :type map
map :: (a -> b) -> [a] -> [b]

map 函数的参数顺序和它有点不对应，我们可以改成这样：

ghci> :type (>>=)
(>>=) :: (Monad m) => m a -> (a -> m b) -> m b
ghci> :type flip map
flip map :: [a] -> (a -> b) -> [b]

但是还是有一点小问题： flip map 的第二个参数的类型是 a -> b ，但是 (>>=) 的第二个参数的类型是 a -> [b] ,应该怎么办呢？

我们对类型进行更多的替换，看看会发生什么。 flip map 这个函数能把任何类型 b 作为返回结果；如果我们使用 [b] 来替换 b ，这个函数的类型就成了 a -> (a -> [n]) -> [[b]]. 换句话说，如果我们使用 map ，将一个列表与一个返回列表的函数进行映射，我们会得到一个包含列表的列表。

ghci> flip map [1,2,3] (\a -> [a,a+100])
[[1,101],[2,102],[3,103]]

有趣的是，我们这么做并没有让 flip map 和 (>>=) 的类型更加匹配一点； (>>=) 的类型是 [a] -> (a -> [b]) -> [b] ；然而，flip map 如果对返回列表的函数进行map那么它的类型签名是 [a] -> (a -> [b]) -> [[b]] .在类型上依然是不匹配的，我们仅仅是把不匹配的类型从中间转移到了末尾。但是，我们的努力并没有白费：我们现在其实只需要一个能把 [[b]] 转化成 [b] 的函数就好了。很明显 concat 符合我们的要求。

ghci> :type concat
concat :: [[a]] -> [a]

(>>=) 的类型告诉我们应该把 map 的参数进行翻转，然后使用 concat 进行处理得到单个列表。

ghci> :type \xs f -> concat (map f xs)
\xs f -> concat (map f xs) :: [a] -> (a -> [a1]) -> [a1]

事实上lists的 (>>=) 定义就是这样：

-- file: ch14/ListMonad.hs
instance Monad [] where
    return x = [x]
        xs >>= f = concat (map f xs)

它使用函数 f 对列表 xs 的每一个元素 x 进行处理，然后把得到的结果拼接起来得到单个列表。

现在我们已经搞定了List这个Monad的两个核心函数，另外两个非核心函数实现起来就很容易了：

-- file: ch14/ListMonad.hs
    xs >> f = concat (map (\_ -> f) xs)
    fail _ = []

-- file: ch14/CartesianProduct.hs
comprehensive xs ys = [(x,y) | x <- xs, y <- ys]

-- file: ch14/CartesianProduct.hs
monadic xs ys = do { x <- xs; y <- ys; return (x,y) }

ghci> comprehensive [1,2] "bar"
[(1,'b'),(1,'a'),(1,'r'),(2,'b'),(2,'a'),(2,'r')]
ghci> comprehensive [1,2] "bar" == monadic [1,2] "bar"
True

-- file: ch14/CartesianProduct.hs
blockyDo xs ys = do
    x <- xs
    y <- ys
    return (x, y)

-- file: ch14/CartesianProduct.hs
blockyPlain xs ys =
    xs >>=
    \x -> ys >>=
    \y -> return (x, y)

blockyPlain_reloaded xs ys =
    concat (map (\x ->
                 concat (map (\y ->
                              return (x, y))
                         ys))
            xs)

-- file: ch14/MultiplyTo.hs
guarded :: Bool -> [a] -> [a]
guarded True  xs = xs
guarded False _  = []

multiplyTo :: Int -> [(Int, Int)]
multiplyTo n = do
  x <- [1..n]
  y <- [x..n]
  guarded (x * y == n) $
    return (x, y)

ghci> multiplyTo 8
[(1,8),(2,4)]
ghci> multiplyTo 100
[(1,100),(2,50),(4,25),(5,20),(10,10)]
ghci> multiplyTo 891
[(1,891),(3,297),(9,99),(11,81),(27,33)]

还原do的本质¶

Haskell的 do 表示法实际上是个语法糖：它给我们提供了一种不使用 (>>=) 和匿名函数来写monadic代码的方式。去除do语法糖的过程就是把它翻译为 (>>=) 和匿名函数。

去除do语法糖的规则非常简单。我们可以简单的把编译器想象为机械重复地对这些do语句块执行这些规则直到没有任何do关键字为止。

do 关键字后面接单个动作（action）直接翻译为动作本身。

-- file: ch14/Do.hs
doNotation1 =
    do act

-- file: ch14/Do.hs
translated1 =
    act

do 后面包含多个动作（action）的表示是这样的：首先是第一个动作，但是接一个 (>>) 操作符，然后一个 do 关键字；最后接剩下的动作。当我们对do语句块重复应用这条规则的时候，整个do语句快就会被 (>>) 串联起来。

-- file: ch14/Do.hs
doNotation2 =
    do act1
       act2
       {- ... etc. -}
       actN

-- file: ch14/Do.hs
translated2 =
    act1 >>
    do act2
       {- ... etc. -}
       actN

finalTranslation2 =
    act1 >>
    act2 >>
    {- ... etc. -}
    actN

<- 标记需