Hi Michael, You're wrong :)

foldr (||) False (repeat True)

Gives:

True

Remember that in Haskell everything is lazy, which means that the || short-circuits as soon as it can. Thanks Neil On 6/22/07, Michael T. Richter wrote:

So, I'm now going over the code in the 'Report with a fine-toothed comb because a) I'm actually able to read it now pretty fluently and b) I want to know what's there in detail for a project I'm starting. I stumbled across this code:

any :: (a -> Bool) -> [a] -> Bool any p = or . map p

or :: [Bool] -> Bool or = foldr (||) False

Now I see how this works and it's all elegant and clear and all that. But I have two nagging problems with it (that are likely related):

1. Using foldr means I'll be traversing the whole list no matter what. This implies (perhaps for a good reason) that it can only work on a finite list. 2. I don't see any early bale-out semantics. The way I read this it's going to expand a whole list of n and perform n comparisons (including the one with the provided False).

Considering that I only need a single True result to make the whole expression true, I'd have expected there to be some clever semantics to allow exactly this. But what I'm seeing, unless I'm really misreading the code, is that if I give it a list of a million boolean expressions, it will cheerfully evaluate these million boolean expressions and perform a million calls to (||) before giving me a result.

Please tell me I'm wrong and that I'm missing something?

-- *Michael T. Richter* (*GoogleTalk:* ttmrichter@gmail.com) *There are two ways of constructing a software design. One way is to make it so simple that there are obviously no deficiencies. And the other way is to make it so complicated that there are no obvious deficiencies. (Charles Hoare)*

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

On 22/06/07, Michael T. Richter wrote:

So, I'm now going over the code in the 'Report with a fine-toothed comb because a) I'm actually able to read it now pretty fluently and b) I want to know what's there in detail for a project I'm starting. I stumbled across this code:

any :: (a -> Bool) -> [a] -> Bool any p = or . map p

or :: [Bool] -> Bool or = foldr (||) False

Now I see how this works and it's all elegant and clear and all that. But I have two nagging problems with it (that are likely related):

Using foldr means I'll be traversing the whole list no matter what. This implies (perhaps for a good reason) that it can only work on a finite list. I don't see any early bale-out semantics. The way I read this it's going to expand a whole list of n and perform n comparisons (including the one with the provided False).

Well, try it: Prelude> any (>10) [1..] True By way of contrast, this (doesn't) work as you expected: Prelude> let any' p = foldl (||) False . map p Prelude> any' (>10) [1..] ^C Interrupted. A left fold will keep on going with an infinite list in this case. D.

This is how I think of it: lazyIntMult :: Int -> Int -> Int lazyIntMult 0 _ = 0 lazyIntMult _ 0 = 0 lazyIntMult a b = a * b *Q> 0 * (5 `div` 0) *** Exception: divide by zero *Q> 0 `lazyIntMult` (5 `div` 0) 0 foldr evaluates a `f` (b `f` (c `f` ...)) Only f knows which arguments are strict and in which order to evaluate them. foldr knows nothing about evaluation order. Dan Michael T. Richter wrote:

So, I'm now going over the code in the 'Report with a fine-toothed comb because a) I'm actually able to read it now pretty fluently and b) I want to know what's there in detail for a project I'm starting. I stumbled across this code:

any :: (a -> Bool) -> [a] -> Bool any p = or . map p

or :: [Bool] -> Bool or = foldr (||) False

Now I see how this works and it's all elegant and clear and all that. But I have two nagging problems with it (that are likely related):

1. Using foldr means I'll be traversing the whole list no matter what. This implies (perhaps for a good reason) that it can only work on a finite list. 2. I don't see any early bale-out semantics. The way I read this it's going to expand a whole list of n and perform n comparisons (including the one with the provided False).

Considering that I only need a single True result to make the whole expression true, I'd have expected there to be some clever semantics to allow exactly this. But what I'm seeing, unless I'm really misreading the code, is that if I give it a list of a million boolean expressions, it will cheerfully evaluate these million boolean expressions and perform a million calls to (||) before giving me a result.

Please tell me I'm wrong and that I'm missing something?

-- *Michael T. Richter* mailto:ttmrichter@gmail.com> (*GoogleTalk:* ttmrichter@gmail.com) /There are two ways of constructing a software design. One way is to make it so simple that there are obviously no deficiencies. And the other way is to make it so complicated that there are no obvious deficiencies. (Charles Hoare)/

------------------------------------------------------------------------

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe