为了理解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]的实际作用
答案 0 :(得分：2)
与“ Haskell”标准类的方法相比，使用“数学定义”通常更容易理解单子。即
class Applicative' m => Monadd m where
join :: m (m a) -> m a
请注意，您可以在此方面实现标准版本，反之亦然：
join mma = mma >>= id
ma >>= f = join (fmap f ma)
对于列表，join（又名concat）非常简单：
join :: [[a]] -> [a]
join xss = [x | xs <- xss, x <- xs] -- xss::[[a]], xs::[a]
-- join [[1],[2]] ≡ [1,2]
对于您发现令人困惑的示例，您将拥有
[1,2,3,4] >>= \x->[(x+1)]
≡ join $ fmap (\x->[(x+1)]) [1,2,3,4]
≡ join [[1+1], [2+1], [3+1], [4+1]]
≡ join [[2],[3],[4],[5]]
≡ [2,3,4,5]
答案 1 :(得分：2)
Wadler，School of Haskell，LYAH，HaskellWiki，Quora，还有更多描述列表单子。
比较：
(=<<) :: Monad m => (a -> m b) -> m a -> m b用于具有concatMap :: (a -> [b]) -> [a] -> [b] for m = []。常规(>>=)绑定操作符的参数已被翻转，但否则只是一个前缀concatMap。
或者很简单，我的困惑似乎是由于不了解该语句的实际工作原理而产生的：
(>>|) xs f = [ y | x <- xs, y <- f x ]
由于列表推导与列表的Monad实例等效，因此此定义是一种作弊行为。您基本上是在说某种东西是一种Monad，就象它是Monad一样，因此您将面临两个问题：了解列表理解和仍然了解Monad。
可以理解列表的理解以便更好地理解：
对于您而言，该语句可以通过多种其他方式编写：
使用符号：
(>>|) xs f = do x <- xs
y <- f x
return y
建议使用(>>=)运算符：
(>>|) 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的内容。我不确定为什么会丢失它。
答案 2 :(得分：2)
List comprehensions就像嵌套循环一样：
xs >>| foo = [ y | x <- xs, y <- foo x]
-- = for x in xs:
-- for y in (foo x):
-- yield y
因此我们有
[1,2,3,4] >>| (\x -> [x, x+10])
=
[ y | x <- [1,2,3,4], y <- (\x -> [x, x+10]) x]
=
[ y | x <- [1] ++ [2,3,4], y <- [x, x+10]]
=
[ y | x <- [1], y <- [x, x+10]] ++ [ y | x <- [2,3,4], y <- [x, x+10]] -- (*)
=
[ y | y <- [1, 1+10]] ++ [ y | x <- [2,3,4], y <- [x, x+10]]
=
[ y | y <- [1]] ++ [ y | y <- [11]] ++ [ y | x <- [2,3,4], y <- [x, x+10]]
=
[1] ++ [11] ++ [ y | x <- [2,3,4], y <- [x, x+10]]
=
[1, 11] ++ [2, 12] ++ [ y | x <- [3,4], y <- [x, x+10]]
=
[1, 11] ++ [2, 12] ++ [3, 13] ++ [ y | x <- [4], y <- [x, x+10]]
=
[1, 11] ++ [2, 12] ++ [3, 13] ++ [4, 14]
关键步骤标记为(*)。您可以将其作为是的列表理解的定义。
一种特殊情况是foo函数返回单例列表，就像您的问题一样。那么，这实际上等同于 mapping ，因为输入列表中的每个元素都将变成输出列表中的一个（已转换）元素。
但是列表理解功能更强大。输入元素也可以有条件地转换为无元素（用作 filter ）或多个元素：
[ a, [a1, a2] ++ concat [ [a1, a2], [ a1, a2,
b, ==> [b1] ++ == [b1], == b1,
c, [] ++ [],
d ] [d1, d2] [d1, d2] ] d1, d2 ]
以上等同于
concat (map foo [a,b,c,d])
=
foo a ++ foo b ++ foo c ++ foo d
表示适当的foo。
concat是列表monad的join，而map是列表monad的fmap。一般来说，对于任何monad，
m >>= foo = join (fmap foo m)
Monad的本质是：从“结构”中的每个实体中，有条件地以相同类型的结构产生新元素，并将它们拼接就位：
[ a , b , c , d ]
/ \ | | / \
[ [a1, a2] , [b1] , [] , [d1, d2] ] -- fmap foo = [foo x | x <- xs]
-- = [y | x <- xs, y <- [foo x]]
[ a1, a2 , b1 , d1, d2 ] -- join (fmap foo) = [y | x <- xs, y <- foo x ]