What is a solid example of something that can be done with list comprehensions that is tricky with high order functions?

Question

I've heard from many Pythonists that they prefer list comprehensions because they can do everything you can do using high order functions such as filter and reduce, and more. So this question address them: what is a solid example of something you can do with them, that is tricky to do with HOFs?

Answer 1

The answer is that there is no such example. Everything you can do with list comprehensions has a mechanical translation to higher-order functions. In fact, this is how Haskell implements list comprehensions: it desugars them to higher-order functions.

Given a list comprehension like this:

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

Haskell desugars it to:

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

Similarly, if you put in predicates like:

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

... then that desugars to:

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

In fact, this desugaring is part of the Haskell specification, which you can find here.

Answer 2

As has been said, everything you can do with list comprehensions can be desugared into higher-order functions, but a large part of the problem with doing this in Python is that Python lacks support for the kind of point-free programming you can use with filter, map, and friends in Haskell. Here's a somewhat contrived example, but I think you'll get the idea.

Let's take this Python code:

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

All it does is print this out:

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

Here's the equivalent version with filter:

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

I hope you'll agree with me that it's a lot uglier. There isn't really much you can do to make it less ugly without defining a separate function.

But let's look at the equivalent version in Haskell:

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

Okay, pretty much as good as the Python list comprehension version. What about the equivalent filter version?

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

Okay, we had to do an import, but the code is (imo) a lot clearer once you understand what it does, although some people might still prefer f to be pointed, or even a lambda with filter. In my opinion the point-free version is more concise and conceptually clear. But the main point I want to make is that it is not really going to be this clear in Python because of the inability to partially apply functions without bringing in a separate library, and the lack of a composition operator, so in Python it is a good idea to prefer list comprehensions over map/filter, but in Haskell it can go either way depending on the specific problem.