Haskell：列表理解谓词顺序

Question

After reading about the Haskell syntax for List Comprehensions online, I got the feeling that predicates always come last. Eg:

[(x,y) | x <- [1..10000], y <- [1..100], x==2000, odd y]

But the following line accomplishes the same result:

[(x,y) | x <- [1..10000], x==2000, y <- [1..100], odd y]

Normally I would just take this as a hint that the order doesn't matter and be done with it. However this is a problem that comes from an old exam, and the answer to the problem says that while the results may be the same, the way in which they are computed may differ.

I'm assuming this is true but I can't find any information about it on the web. So my question is : How could the computations differ between the two list comprehensions and why? Are list comprehensions some form of syntactic sugar that I don't know about?

Answer 1

You can think of a list comprehension like

[(x,y) | x <- [1..10000], y <- [1..100], x==2000, odd y]

as corresponding to the imperative pseudo-code

for x in [1..10000]:
    for y in [1..100];
        if x == 2000:
            if odd y:
                yield (x,y)

and

[(x,y) | x <- [1..10000], x==2000, y <- [1..100], odd y]

as corresponding to

for x in [1..10000]:
    if x == 2000;
        for y in [1..100]:
            if odd y:
                yield (x,y)

Specifically, passing the list comprehension to something like mapM_ print is the same operationally as replacing yield by print in the imperative version.

Obviously, it's almost always better to "float" a guard/ if out of a generator/ for when possible. (The rare exception is when the generator is actually an empty list, and the guard condition is expensive to compute.)

Answer 2

They differ in the way of how many intermediary results/lists are generated.

You can visualize this with some trace - note that I modified this a bit to give reasonable results - also I replaced the return values by () to make it clearer:

comprehension1 = [ () | x <- [1..3], trace' 'x' x, y <- [1..3], trace' 'y' y, x==2, odd y]
comprehension2 = [ () | x <- [1..3], trace' 'x' x, x==2, y <- [1..3], trace' 'y' y, odd y]

trace' :: Show a => Char -> a -> Bool
trace' c x = trace (c : '=' : show x) True

here is the evaluation:

λ> comprehension1
x=1
y=1
y=2
y=3
x=2
y=1
[()y=2
y=3
,()x=3
y=1
y=2
y=3
]
λ> comprehension2
x=1
x=2
y=1
[()y=2
y=3
,()x=3
]

now do you notice something?

Obviously in the first example every (x,y) pair for x=1,2,3 and y=1,2,3 is generated before the filters are applied.

But in the second example the y s are only generated when x=2 - so you could say it's better /more performant