Comments on: Haskell is possibly too lazy for me

By: apfelmus

apfelmus — Fri, 21 Mar 2008 15:54:12 +0000

Be sure to explore both sides of the laziness coin. As your post shows, some programs you write in O’Caml aren’t written the same way in Haskell (the corrections are really minor, though). But there are also Haskell programs you can’t write that way in O’Caml, these are where laziness shines.

By: Cale Gibbard

Cale Gibbard — Fri, 21 Mar 2008 06:42:45 +0000

foldl’ (+) 0

By: Christophe Poucet (vincenz)

Christophe Poucet (vincenz) — Fri, 21 Mar 2008 03:05:32 +0000

One additional note. It is unfair to claim this is an issue with Haskell. I see that you are on the O’Caml planet-list. I am 100% sure that you would write this as a tail-recursive loop in O’Caml as well. So the first sample you show is not even a fair objection.

By: Christophe Poucet (vincenz)

Christophe Poucet (vincenz) — Fri, 21 Mar 2008 03:02:58 +0000

I would simply use:

module Main where

mysumas !acc [] = acc
mysumas !acc (x:xs) = mysumas (acc+x) xs
main = putStrLn $ show $ mysumas 0 $ take 100000 $ [1..]

And compile wih ‘ghc -fbang-patterns –make Main.hs’.

Some additional notes that led to this solution:
1) It is clear that this requires a tail-recursive loop as it produces non-lazy data. (There is some better term for ‘non-lazy’ but I’m sure an expert can help you there)
2) When doing tail-recursion, you want to make your accumulator strict. This is easily done with the ! bit
3) Normally I would not even define a function that traverses lists in such a trivial manner by using pattern-matching. I would simply use fold. And in this case the correct fold (namely for non-lazy data) is foldl’. This is a reasonably quick-learned fact if one spends time in the Haskell community (be it the mailing-list or the IRC channel). In fact, it would probably be the first answer to anyone asking how to make this code better, by most any Haskeller.

By: Adam Langley

Adam Langley — Fri, 21 Mar 2008 02:23:42 +0000

You’re perfectly correct that it can be tough for even for the experts to evaluate the time and space usage of a given bit of code. It’s an issue. However, you can learn a few combinators which solve the problem 90% of the time.

For example, when you see “I want to compute a value of a list, strictly”, you should think “foldl’”:

Prelude Data.List> foldl’ (+) 0 $ take 1000000 [1..]
500000500000

AGL