在 Haskell 中，列表理解的内部工作原理是什么？

Question

我是 Haskell 的新手，我在这里查看了这篇文章：Cartesian product of 2 lists in Haskell。

在答案中有这个sn-p的代码：

cartProd xs ys = [(x,y) | x <- xs, y <- ys]

这两个列表中的哪一个：

xs = [1,2,3]
ys = [4,5,6]

会产生

[(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]

如果我没有看到这个结果，我会认为它会返回

[(1,4),(2,5),(3,6)]

因为它会同时遍历两个列表。

但现在它 - 对于我更了解的编程语言 - 看起来像是用于遍历矩阵的双 for 循环：

for (int x = 1; x < 4; x++)
    for(int y = 4; y < 7; y++)
        //make tuple (x,y)

是什么导致列表推导以这种方式运行？

Answer 1

这个introduction 解释了列表理解的语法。基本上可以说每个x <- list 意味着一个额外的嵌套“for”循环来生成元组，并且每个谓词都经过简单的测试。因此表达式：

[(x,y) | x <- xs, even x, y <- ys, even 3*y-div x 2]

将被翻译成命令式语言：

for (var x : xs) {
    if(even(x)) {
    for(var y : ys) {
        if(even(3*y-x/2)) {
            yield (x,y)
        }
    }
}

yield 是有时与协程一起使用的关键字。此外，对于yield，评估是懒惰的。例如，这可以生成 all 偶数整数：

[x|x <-[2..],even x]

列出单子

为了从根本上理解列表理解，需要知道Monads 是什么。每个列表推导式都可以翻译成 list monad。例如你的例子被翻译成：

do x <- xs
   (do y <- ys
       return (x,y))

这又是语法糖：

xs >>= (\x -> (ys >>= \y -> return (x,y)))

monad 是函数式编程中的一个重要概念（可能更好地阅读维基百科页面），因为它有点难以掌握。有时说一个 monads 就像墨西哥卷饼，....

一旦你或多或少地理解了一个 monad：一个 monad 是一个类型类，带有一个 return 语句和一个 >>= 通道语句。现在内部的return 语句很简单：

return x = [x]

这意味着每次设置x 和y 时，您将创建一个元组(x,y) 并将其作为单例列表返回：因此[(x,y)]。现在“绑定”运算符>>= 需要将ys 和\y -> return (x,y)“粘合”在一起。这是通过将其实现为：

(>>=) xs f = concat $ map f xs

换句话说，您进行映射并连接映射的结果。

现在如果考虑不加糖的表达式的第二部分：

ys >>= \y -> return (x,y)

这意味着对于给定的x（我们现在抽象掉），我们会将ys 中的每个元素映射到一个元组(x,y) 并返回它。因此，我们将生成一个列表列表，每个列表都是包含一个元组的单例。类似的东西（如果ys=[1,2]）：

[[(x,1)],[(x,2)]]

现在>>= 将进一步concat 变成：

\x -> [(x,1),(x,2)]

到目前为止，我们已经将x 抽象出来（假设它是一个）。但现在我们可以取该表达式的第一部分：

xs >>= \x -> [(x,1),(x,2)]

如果xs=[3,5]，则表示我们将重新创建列表：

[[(3,1),(3,2)],[(5,1),(5,2)]]

在 concat 之后：

[(3,1),(3,2),(5,1),(5,2)]

这是我们的期望：

[(x,y)|x<-[3,5],y<-[1,2]]

Answer 2

引用 Haskell 报告，列表推导的评估如下：

[ e | True ]   = [e]
[ e | q ]      = [ e | q, True ]
[ e | b,  Q  ] = if b then [ e | Q ] else []
[ e | p <- l,  Q ] = let ok p = [ e | Q ]
                         ok _ = []
                     in concatMap ok  l
[ e | let decls,  Q ] = let decls in [ e | Q ]

在您的情况下，相关部分是，因为模式 p 只是一个变量 x：

[ e | x <- l, Q ] = concatMap (\x -> [ e | Q ]) l

更具体地说，理解 [(x,y) | x <- xs, y <- ys] 被翻译成

concatMap (\x -> [(x,y) | y <- ys]) xs

根据concatMap的定义，它是

concat (map (\x -> [(x,y) | y <- ys]) xs)

让我们用具体值替换xs,ys：

concat (map (\x -> [(x,y) | y <- [4,5,6]]) [1,2,3])

申请map:

concat [ [(1,y) | y <- [4,5,6]] 
       , [(2,y) | y <- [4,5,6]] 
       , [(3,y) | y <- [4,5,6]] ]

评估内部列表推导：（这些可以使用上面的定律再次翻译，但我会简短）

concat [ [(1,4),(1,5),(1,6)]
       , [(2,4),(2,5),(2,6)]
       , [(3,4),(3,5),(3,6)] ]

通过连接上面的列表，我们得到了结果，

       [  (1,4),(1,5),(1,6) 
       ,  (2,4),(2,5),(2,6) 
       ,  (3,4),(3,5),(3,6)  ]

---

请注意，GHC 还作为 Haskell 扩展实现了所谓的并行列表推导，它确实按您的预期运行：

> :set -XParallelListComp
> [(x,y)| x<-[1,2,3] | y <-[4,5,6]]
[(1,4),(2,5),(3,6)]

在内部，他们使用zip（或者更确切地说，zipWith）函数。

Answer 3

列表解析语法背后的思想来自数学中的set-builder notation。

在数学中，可以这样写：

{ (x, y) | x ∈ xs, y ∈ ys }

表示“所有元素的集合，形式为 (x, y)，其中 x 是集合 xs 的一个元素，y 是集合 ys 的一个元素”。

现在我们想把这个集合构建器的想法变成编程语言的“列表构建器”语法。所以我们想要这个：

[ (x, y) | x <- xs, y <- ys ]

表示“包含 (x, y) 形式的所有元素的列表，其中 x 是从 xs 获得的元素，y 是从 ys 获得的元素”。

很明显，如果这个列表表示法产生了列表[(1,4),(2,5),(3,6)]（当xs = [1, 2, 3] 和ys = [4, 5, 6] 时）它根本不会是所需形式的所有对：(1, 6) 是一个可以从@ 获得的元素987654328@ 与可以从 ys 获得的元素配对，但它不在您的列表中。

所以对于“是什么导致列表理解以这种方式运行？”的真正陈词滥调的答案是什么？是不是它被编程以这种方式运行，因为这就是想出它的人希望它的行为方式。

您可以通过多种不同的方式对这种行为进行编程。您可以（正如 OP 注意到的那样）使用嵌套循环，或者您可以使用 map 和 concat 之类的函数，或者您可以将 Monad 实例用于列表等。因此，您可以将列表理解语法转换为任何这些是为了证明列表推导是“真正的单子”或“真正的嵌套循环”或其他。

但从根本上说，列表推导式是组合式的，而不是压缩式的，因为语言设计者特意选择了表达该含义的语法，以便它有点像数学中的集合构建符号¹。 “x 保持不变，而 y 递增”不仅仅是实现的一个有趣的怪癖，该实现是选择专门为此而设计的。如果有一些替代宇宙，其中列表单子（或嵌套循环等）对此目的没有用，列表推导式不会在该宇宙中产生不同的结果，它们将通过其他方式实现以产生相同的结果。

---

¹ 列表解析语法和集合生成器表示法之间存在显着差异，尽管它们看起来很相似。一个根本的区别来自使用列表而不是集合。一个元素要么在集合中，要么不在集合中，但列表包含特定索引处的元素（包括在多个索引处包含给定元素的可能性）。

所以列表推导式语法必须定义 order 它将产生其元素（以及它将产生多少元素），这使得列表推导式从根本上与 枚举 ，而 set-builder 表示法基本上是关于 membership。 set-builder 符号{ (x, y) | x ∈ xs, y ∈ ys } 真正的意思是“你可以通过检查 x ∈ xs 和 y ∈ ys 是否在我们正在构建的集合中来回答给定的 (x, y) ”，而列表理解 [ (x, y) | x <- xs, y <- ys ]是说“您可以通过枚举xs 来枚举我们正在构建的列表的元素，然后对每个元素也枚举ys”