为什么此Haskell代码不终止？

Question

Why does the following Haskell code not terminate:

foldr (||) True $ repeat False -- never terminates

when something like this does:

foldr (||) False $ repeat True -- => True

To me, it's the second expression that looks to be in more trouble of not terminating. What's wrong with my view of Haskell's lazy evaluation?

Answer 1

I think your understanding of lazy is correct, but not for foldr . Let's look at its " specification "

foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

Then look at your expression

foldr (||) True $ repeat False -- never terminates

As you see the True ( z ) which we are "looking for" to get || to terminate won't be reached until the whole list is consumed. And that won't happen as the list is infinite.

This should also explain for the actually terminating example.

Answer 2

The first expands to False || (False || (False || ...)) False || (False || (False || ...)) , while the second expands to True || (True || (True || ...)) True || (True || (True || ...)) . The second argument to foldr is a red herring - it appears in the innermost application of || , not the outermost, so it can never actually be reached.

Answer 3

The problem is quite obvious, if you unfold the foldr manually:

foldr (||) True $ repeat False == False || (False || (False (False || ... True)))

So in order to get the final False , the code had to evaluate the list till its (nonexistant) end. In your second example, you repeat True , thus short-circuit evaluation is possible. Don't expect magic from lazy evaluation!

Answer 4

A yet another insight for you is that || is not commutative in Haskell, it's biased :

Prelude> undefined || True
*** Exception: Prelude.undefined
Prelude> True || undefined
True

So unlike in math, || and flip (||) are different functions. Eg compare

foldr (||) False $ repeat True and foldr (flip (||)) False $ repeat True

The former terminates, but the latter don't.