什么是可以通过列表推导完成的事情的一个可靠的例子，这对于高阶函数来说是棘手的？

Question

我从他们更喜欢列表理解许多Pythonists听说过，因为他们可以做的一切，你可以使用高阶功能，如过滤器和减少， 多做 。 所以这个问题解决了这些问题：你可以用它们做些什么的可靠例子，这对HOF来说很棘手？

Answer 1

答案是没有这样的例子。 列表推导所能做的一切都是对高阶函数的机械转换。 事实上，这就是Haskell实现列表推导的方式：它将它们放到高阶函数中。

给出这样的列表理解：

[(x, y) | x <- [1..3], y <- [4..6]]

Haskell贬低它：

concatMap (\x -> concatMap (\y -> [(x, y)]) [4..6]) [1..3]

同样，如果你输入谓词：

[(x, y) | x <- [1..3], y <- [4..6], x + y /= 5]

...然后那个desugars：

concatMap (\x -> concatMap (\y -> if (x + y) == 5 then [(x, y)] else []) [4..6]) [1..3]

实际上，这个desugaring是Haskell规范的一部分，您可以在这里找到它。

Answer 2

如上所述，使用列表推导可以做的所有事情都可以用于高阶函数，但在Python中执行此操作的很大一部分问题是Python缺乏对可以使用的无点编程的支持filter ， map和朋友在Haskell。 这是一个有点人为的例子，但我想你会明白这个想法。

我们来看看这个Python代码：

[(x,y) for x,y in zip(xrange(20), xrange(20, 0, -1)) if x % 2 == 0 and y % 2 == 0]

所有这一切都打印出来：

[(0, 20), (2, 18), (4, 16), (6, 14), (8, 12), (10, 10), (12, 8), (14, 6), (16, 4), (18, 2)]

这是带过滤器的等效版本：

filter(lambda ns : ns[0] % 2 == 0 and ns[1] % 2 == 0, zip(xrange(20), xrange(20, 0, -1)))

我希望你会同意我的意见，这是更加丑陋的。 如果没有定义单独的函数，你可以做的就是不那么难看。

但是让我们看一下Haskell中的等价版本：

[(x,y) | (x,y) <- zip [0..20] [20,19..0], x `mod` 2 == 0 && y `mod` 2 == 0]

好的，几乎和Python列表理解版一样好。 等效过滤器版本怎么样？

import Data.Function
let f = (&&) `on` (==0) . (`mod` 2)
filter (uncurry f) $ zip [0..20] [20,19..0]

好吧，我们必须进行导入，但是一旦你理解了它的作用，代码就会更加清晰，尽管有些人可能仍然喜欢f指向，甚至是带有过滤器的lambda。 在我看来，无点版本更简洁，概念更清晰。 但我要说的主要观点是，Python中并没有真正明白这一点，因为如果不引入单独的库就无法部分应用函数，并且缺少复合运算符，所以在Python中它是一个最好选择列表推导而不是map / filter，但在Haskell中，它可以根据具体问题进行。

Answer 3

在Haskell中，列表推导是条件和函数的“语法糖”（或者可以简单地转换为符号，然后单独地进行desugared）。 以下是翻译它们的“官方”指南： http ： //www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-420003.11

因此，由于列表推导可以使用简单的高阶函数机械地和直接地转换为等价的代码，因此根据定义，没有任何东西可以用它们来做，没有它们很难做到。

Answer 4

其他是正确的; 与map，reduce，filter等函数相比，list comprehensions本身并没有提供任何更好的序列操作。尽管如此，它们并没有真正解决你为什么Python程序员胜过列表推导而不是更高阶函数的问题。

Python提倡它并且Python程序员使用它们的原因是因为根据语言创建者Guido的说法，列表推导（以及设置理解和dict压缩和生成器表达式）比函数表达式更容易阅读和编写。 Python的理念是可读性胜过一切。

Guido一般不喜欢函数式编程结构，并且对添加lambda语法持谨慎态度。 这只是风格和品味的问题，而不是表现力或力量。 他的观点塑造了Python及其编写方式。

有关更多详细信息，请参阅Guido提出的从Python 3及更高版本中删除lambda ， map ， filter和reduce 。 它没有实现（除了删除reduce ，它不再是内置函数），但是他在这里列出了他的推理： http ： //www.artima.com/weblogs/viewpost.jsp？ thread = 98196

不过，他总结如下：

滤波器（P，S）几乎总是更清晰地写成[x表示P中的x，如果P（x）]，这具有巨大的优势，即最常见的用法涉及比较的谓词，例如x == 42，并且定义一个lambda只需要读者更多的努力（加上lambda比列表理解慢）。

Answer 5

相比

    [[x*x, x*x+x ..] | x <- [2..]]

和

    map (\x-> map (*x) $ enumFrom x) $ enumFrom 2

第一个显然更具可读性。 你问“棘手”，而不是“不可能”。 并且使用filter ，没有任何东西可以指示我们是否过滤了或者输出了给定测试通过或失败的元素。 使用LC，它在视觉上是显而易见的。

因此，只要有LC配方，它就是IMO的首选，只是为了它的可读性。 Haskell的LC语法特别简洁明了，比Python的IMO更清晰（ 噪音更小）。 羞于不要使用它。 :)

Answer 6

我很少使用列表推导来解释这个问题的原因。 但是，有一种情况我发现它们是唯一简洁的语法：当一个可反射的模式位于<-的左侧时。 例：

data Foo = Bar Int | Baz String

getBazs :: [Foo] -> [String]
getBazs xs = [x | Baz x <- xs]

要在没有列表理解的情况下编写它，你必须做更长时间的事情：

data Foo = Bar Int | Baz String

getBazs :: [Foo] -> [String]
getBazs = foldr go []
          where go (Baz x) acc = x:acc
                go _       acc =   acc

但与列表理解不同，这不是一个“好的制作者”，所以它的输出列表将无法与任何东西融合。 要解决这个问题，你必须手动添加重写规则，或者切换到导入一个好的生产者的另一个函数：

import Data.Maybe

data Foo = Bar Int | Baz String

getBazs :: [Foo] -> [String]
getBazs = mapMaybe go
          where go (Baz x) = Just x
                go _       = Nothing

对于相同的结果，最终结果是要考虑更多，以及比基本列表理解更多的代码。