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 <- fx] [ y | x <-xs, y <- fx]实际上有效

Answer 1

使用“数学定义”通常比使用 Haskell 标准类的方法更容易理解 Monad。 即，

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]

Answer 2

Wadler 、 Haskell 学院、 LYAH 、 HaskellWiki 、 Quora等都描述了列表 monad。

相比：

• (=<<) :: Monad m => (a -> mb) -> ma -> mb用于列表
• concatMap :: (a -> [b]) -> [a] -> [b] for m = [] 。

常规(>>=)绑定运算符翻转了参数，但在其他方面只是一个中缀concatMap 。

或者很简单，我的困惑似乎源于不了解此语句的实际工作原理：

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

由于列表推导式等同于列表的 Monad 实例，因此这个定义有点像作弊。 您基本上是在说某事物是 Monadd 的方式与它是 Monad 的方式一样，因此您会遇到两个问题：理解列表推导式，以及仍然理解 Monad。

列表推导式可以去除糖分以便更好地理解：

• 删除语法糖：Haskell 中的列表理解

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

• 使用 do-notation：

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

• 去糖化为使用(>>=)运算符：

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

• 这可以缩短（每行重写一次）：

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

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

• 使用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 = fx in ys ++ ((>>|) xs f)

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

Answer 3

列表推导式就像嵌套循环：

   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 ，因为输入列表中的每个元素都变成了输出列表中的一个（转换）元素。

但是列表推导式更强大。 输入元素也可以有条件地转换为无元素（用作过滤器）或多个元素：

  [ 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是 list monad 的join ， map是 list 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 ]