class Monad m where
return :: a -> m a
(>>=) :: m a -> (a -> m b) -> m b
(>>) :: m a -> m b -> m b
x >> y = x >>= \_ -> y
fail :: String -> m a
fail msg = error msg
Monad Law
（1）return x >>= f = f x
（2）m >>= return = m
（3）(m >>= f) >>= g = m >>= (\x -> f x >>= g)
注：
（1）:k m = * -> *
（2）在do notation中模式匹配失败后，程序并不会crash，而是会调用函数fail。
（3）m a类型的值，称为monad value。
（1）Maybe是Monad类型类的实例
instance Monad Maybe where
return x = Just x
Nothing >>= f = Nothing
Just x >>= f = f x
fail _ = Nothing
我们看一下>>=是如何实例化的
(>>=) :: m a -> (a -> m b) -> m b
= Maybe a -> (a -> Maybe b) -> Maybe b
ghci> Just 9 >= \x -> return (x * 10)
Just 90
ghci> Nothing >>= \x -> return (x * 10)
Nothing
注：do notation
ghci> Just 3 >>= \x -> Just “!” >>= \y -> Just (show x ++ y)
Just “3!”
其中，
Just 3 >>= \x -> Just “!” >>= \y -> Just (show x ++ y)
= Just 3 >>= \x -> (Just “!” >>= \y -> Just ((show x) ++ y))
= Just 3 >>= \x ->
Just “!” >>= \y ->
Just (show x ++ y)
= do
x <- Just 3
y <- Just “!”
Just (show x ++ y)
注：
（1）do表达式的结果是一个monad value。
（2）在do表达式中，如果某一行我们没有使用“<-”为monad value绑定值，就相当于使用了函数“>>”，表示不需要这个绑定值。（(>>) :: x >> y = x >>= \_ -> y）
do
Just 1
x <- Just 2
Just x
= Just 1 >> Just 2 >>= \x -> Just x
= Just 1 >>= \_ -> Just 2 >>= \x -> Just x
（2）[]是Monad类型类的实例
instance Monad [] where
return x = [x]
xs >>= f = concat (map f xs)
fail _ = []
ghci> [1,2] >>= \n -> ['a','b'] >>= \ch -> return (n, ch)
[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
推导如下：
[1,2] >>= \n -> ['a','b'] >>= \ch -> return (n, ch)
= concat $ map (\n -> ['a','b'] >>= \ch -> return (n, ch)) [1, 2]
(\n -> ['a','b'] >>= \ch -> return (n, ch)) 1
= ['a','b'] >>= \ch -> return (1, ch)
= concat $ map (\ch -> return (1, ch)) ['a','b']
(\ch -> return (n, ch)) 'a'
= return (1, 'a')
= [(1, 'a')] （自动推导出类型`[(Int,Char)]`）
concat $ map (\ch -> return (1, ch)) ['a','b']
= concat [[(1, 'a')], [(1, 'b')]]
= [(1, 'a'), (1, 'b')]
concat $ map (\n -> ['a','b'] >>= \ch -> return (n, ch)) [1, 2]
= concat [[(1, 'a'), (1, 'b')], [(2, 'a'), (2, 'b')]]
= [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]
写成do notation如下：
[1,2] >>= \n -> ['a','b'] >>= \ch -> return (n, ch)
= do
n <- [1, 2]
ch <- ['a','b']
return (n, ch)
注： list comprehension
ghci> [(n, ch) | n <- [1, 2], ch <- ['a','b']]
[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
所以，list comprehension只是do notation的语法糖。