List monad 在这个例子中是如何工作的？答案

【问题标题】：How does the List monad work in this example?List monad 在这个例子中是如何工作的？
【发布时间】：2018-08-04 06:43:13
【问题描述】：

List monad 有return x = [x]。那么为什么在下面的例子中结果不是[(["a", "b"], [2, 3])]？

> pairs a b = do { x <- a; y <- b; return (x, y)}
> pairs ["a", "b"] [2,3]
[("a",2),("a",3),("b",2),("b",3)]

【问题讨论】：

因为 - list monad 还有一个 (>>=) = concatMap 绑定操作，您可以将其与 (<-) 隐式使用。最好自己尝试对 do 表示法进行脱糖，看看能走多远。要点是您在每个 x <- a 中绑定 monad 的每个元素而不是整个列表。
你了解绑定的工作原理吗？
因为return 有(x, y) 作为参数，所以它产生[(x,y)]。
pairs = return 将提供您的预期价值。 <- 不只是赋值；它更像是一个 extraction 运算符。
@chepner（你的意思是pairs = curry return。）

标签： list haskell monads do-notation

【解决方案1】：

我们先分析重写函数pairs：

pairs a b = do { x <- a; y <- b; return (x, y)}

因此我们在这里有一个单子。我们使用do 作为语法糖。但编译器将其重写为：

pairs a b = a >>= (\x -> b >>= (\y -> return (x, y)))

或者以更规范的形式：

pairs a b = (>>=) a (\x -> (>>=) b (\y -> return (x, y)))

现在列表单子被定义为：

instance Monad [] where
    return x = [x]
    (>>=) xs f = concatMap f xs

所以我们写了：

pairs a b = concatMap (\x -> concatMap (\y -> [(x, y)]) b) a

因此，我们将两个列表a 和b 作为输入，并使用函数(\x -> concatMap (\y -> [(x, y)]) b) 在a 上执行concatMap。在该函数中，我们在 b 上执行另一个 concatMap，并使用函数 \y -> [(x, y)]。

因此，如果我们使用 pairs ["a", "b"] [2,3] 评估它，我们会得到：

   pairs ["a", "b"] [2,3]
-> concatMap (\x -> concatMap (\y -> [(x, y)]) [2,3]) ["a", "b"]
-> concatMap (\y -> [("a", y)]) [2,3] ++ concatMap (\y -> [("b", y)]) [2,3]
-> [("a", 2)] ++ [("a", 3)] ++ [("b", 2)] ++ [("b", 3)]
-> [("a", 2), ("a", 3), ("b", 2), ("b", 3)]

【讨论】：

感谢您的详细说明。我的困惑是

【解决方案2】：

一般来说，

pairs a b = do { x <- a; y <- b; return (x, y) }  
          = do { x <- a;
                    do { y <- b; 
                            do { return (x, y) }}}

表示，在伪代码中，

pairs( a, b) {  for x in a do: 
                     for y in b do: 
                                 yield( (x, y) ); 
             }

无论"for ... in ... do" 和"yield" 对特定的monad 意味着什么。更正式地说，它是

          = a  >>= (\x ->
                    do { y <- b;                          -- a >>= k  ===
                            do { return (x, y) }})        -- join (k <$> a)
          = join ( (<$> a)                                --  ( a       :: m a
                   (\x ->                                 --    k       ::   a ->   m b
                    do { y <- b;                          --    k <$> a :: m       (m b) )
                            do { return (x, y) }}) )      --            :: m          b

（(<$>) 是fmap 的别名）。

对于Identity monad，其中return a = Identity a 和join (Identity (Identity a)) = Identity a，确实是

pairs( {Identity, a}, {Identity, b}) {  x = a; 
                                        y = b; 
                                        yield( {Identity, {Pair, x, y}} ); 
                                     }

对于列表 monad，"for" 表示 foreach，因为 return x = [x] 和 join xs = concat xs：

-- join :: m (m a) -> m a
-- join :: [] ([] a) -> [] a
-- join :: [[a]] -> [a]
join = concat

等等，

join    [ [a1, a2, a3, ...],
          [b1, b2, b3, ...],
           .....
          [z1, z2, z3, ...] ]
=
        [  a1, a2, a3, ... ,
           b1, b2, b3, ... ,
            .....
           z1, z2, z3, ...  ]

一元绑定满足ma >>= k = join (fmap k ma)，其中ma :: m a, k :: a -> m b 为Monad m。因此对于列表，fmap = map，我们有ma >>= k = join (fmap k ma) = concat (map k ma) = concatMap k ma：

m >>= k  =  [ a,        = join [ k a,   = join [ [ a1, a2, ... ],  =  [  a1, a2, ... ,
              b,                 k b,            [ b1, b2, ... ],        b1, b2, ... ,
              c,                 k c,            [ c1, c2, ... ],        c1, c2, ... ,
              d,                 k d,            [ d1, d2, ... ],        d1, d2, ... ,
              e,                 k e,            [ e1, e2, ... ],        e1, e2, ... ,
             ... ] >>= k         ...  ]          ...............  ]      ...........   ]

这正是 嵌套循环 所做的。因此

pairs ["a",                                   -- for x in ["a", "b"] do:
       "b"] [2, 3]                            --          for y in [2, 3] do:
=                                             --                     yield (x,y)
      ["a", 
       "b"] >>= (\x-> join (fmap (\y -> return (x,y)) [2, 3]) )
=
      ["a", 
       "b"] >>= (\x-> concat (map (\y -> [ (x,y) ]) [2, 3]) )
=
join [ "a"  &   (\x-> concat ((\y -> [ (x,y) ]) `map` [2, 3]) ),      -- x & f = f x
       "b"  &   (\x-> concat ((\y -> [ (x,y) ]) `map` [2, 3]) ) ]     
=
join [              concat ((\y -> [ ("a",y) ]) `map` [2, 3])  ,    
                    concat ((\y -> [ ("b",y) ]) `map` [2, 3])   ]     
=
join [ concat [ [("a", 2)], [("a", 3)] ] ,    -- for y in [2, 3] do: yield ("a",y)
       concat [ [("b", 2)], [("b", 3)] ] ]    -- for y in [2, 3] do: yield ("b",y)
=
join [        [  ("a", 2) ,  ("a", 3)  ] ,
              [  ("b", 2) ,  ("b", 3)  ] ]
=
     [           ("a", 2) ,  ("a", 3)    ,
                 ("b", 2) ,  ("b", 3)    ]

循环展开是嵌套循环所做的 ⁄ 是，嵌套计算是 Monad 的精髓。

注意到这一点也很有趣

 join                =                      =   [a1] ++            =  [a1] ++ join
  [ [ a1, a2, ... ],    [ a1, a2, ... ] ++          [a2, ... ] ++         [ [a2, ...],
    [ b1, b2, ... ],    [ b1, b2, ... ] ++     [ b1, b2, ... ] ++      [ b1, b2, ...],
    [ c1, c2, ... ],    [ c1, c2, ... ] ++     [ c1, c2, ... ] ++      [ c1, c2, ...],
    [ d1, d2, ... ],    [ d1, d2, ... ] ++     [ d1, d2, ... ] ++      [ d1, d2, ...],
    [ e1, e2, ... ],    [ e1, e2, ... ] ++     [ e1, e2, ... ] ++      [ e1, e2, ...],
    ............... ]   ...............        ...............         ..............  ]

这是“嵌套循环 ⁄ 产出”类比的核心。 Monad 是高阶幺半群，“有什么问题？”

【讨论】：