list - Haskell Monad - 列表中的 Monad 如何工作？

Question

为了理解 Monad，我提出了以下定义:

class Applicative' f where
 purea :: a -> f a
 app :: f (a->b) -> f a -> f b

class Applicative' m =>  Monadd m where
 (>>|) :: m a -> (a -> m b) -> m b

instance Applicative' [] where
 purea x = [x]
 app gs xs = [g x | g <- gs, x <- xs]

instance Monadd [] where
 (>>|) xs f = [ y | x <-xs, y <- f x]

它按预期工作:

(>>|) [1,2,3,4] (\x->[(x+1)])
[2,3,4,5]

虽然我不确定它是如何工作的。例如:

[ y | y <- [[1],[2]]]
[[1],[2]]

如何申请(\x->([x+1]) [1,2,3] 的每个列表元素结果 [2,3,4]而不是 [[2],[3],[4]]

或者很简单，我的困惑似乎源于不理解这个声明 [ y | x <-xs, y <- f x]实际工作

Answer 1

Wadler , School of Haskell , LYAH , HaskellWiki , Quora以及更多描述列表 monad 的内容。

比较:

• (=<<) :: Monad m => (a -> m b) -> m a -> m b对于带有
的列表
• concatMap :: (a -> [b]) -> [a] -> [b] 对于 m = [] .

常规(>>=)绑定(bind)运算符翻转了参数，但除此之外只是一个中缀 concatMap .

Or quite simply my confusion seems to stem from not understanding how this statement actually works:

(>>|) xs f = [ y | x <- xs, y <- f x ]

由于列表理解等同于列表的 Monad 实例，这个定义有点作弊。您基本上是在说某物是 Monadd，就像它是 Monad 一样，所以您面临两个问题:理解列表理解，以及仍然理解 Monad。

为了更好地理解，可以对列表推导式进行去糖处理:

• Removing syntactic sugar: List comprehension in Haskell

在您的情况下，语句可以用多种其他方式编写:

• 使用 do-notation:

  (>>|) xs f = do x <- xs
                  y <- f x
                  return y
  

• 使用 (>>=) 脱糖运算符(operator):

  (>>|) xs f = xs >>= \x ->
               f x >>= \y ->
               return y
  

• 这可以缩短(每行重写一次):

    (>>|) xs f = xs >>= \x -> f x >>= \y -> return y -- eta-reduction
  ≡ (>>|) xs f = xs >>= \x -> f x >>= return         -- monad identity
  ≡ (>>|) xs f = xs >>= \x -> f x                    -- eta-reduction
  ≡ (>>|) xs f = xs >>= f                            -- prefix operator
  ≡ (>>|) xs f = (>>=) xs f                          -- point-free
  ≡ (>>|) = (>>=)
  

因此，通过使用列表推导，您并没有真正声明一个新的定义，您只是依赖于现有的定义。如果你愿意，你可以改为定义你的 instance Monadd []不依赖现有的 Monad 实例或列表理解:

• 使用 concatMap :

  instance Monadd [] where
    (>>|) xs f = concatMap f xs
  

• 再详细说明一下:

  instance Monadd [] where
    (>>|) xs f = concat (map f xs)
  

• 进一步说明:

  instance Monadd [] where
    (>>|) [] f = []
    (>>|) (x:xs) f = let ys = f x in ys ++ ((>>|) xs f)
  

Monadd 类型类应该有类似 return 的东西.我不确定为什么它不见了。