2008/3/1, Milos Hasan <[EMAIL PROTECTED]>:
> OK, thanks, this is an important point. So maybe I should have done this?
>
> main = print $ foldl1' (+) $! take 100 randFloats
>
> My intuition tells me that the $! (and `seq`) just reduces one level (to
> WHNF?). If so, is there a way to force c
It is definitely the strictness analyzer biting you here. In ghci,
the behavior of these two programs is identical (stack overflow). As
kalman said, if you replate sum with foldl' (+) 0 in each of these
programs, the behavior is still identical (correct).
OK, I could replicate that result
The following is in ghci 6.8.2 with default options (e.g., default heap
and stack). "G>" denotes the ghci prompt.
At some points ghci will use 500MB of memory. Be sure you have enough
physical memory.
G> :m + Data.List System.Random
G> let f n = take n randoms (mkStdGen 0)) :: [Float]
I defi
On Sat, Mar 1, 2008 at 8:18 AM, Milos Hasan <[EMAIL PROTECTED]> wrote:
> Here's a minimal summing example that illustrates the difference. The
> following works fine, since the elements are generated lazily and summed
> on the fly, as expected:
>
> randFloats :: [Float]
> randFloats = randoms
Milos Hasan wrote:
> Here's a minimal summing example that illustrates the difference. The
> following works fine, since the elements are generated lazily and summed
> on the fly, as expected:
>
> randFloats :: [Float]
> randFloats = randoms (mkStdGen 0)
>
> main = do
>let xs = take 100
So, I did one more experiment, and the following overflows too:
import System.Random
import Data.List
randFloats :: [Float]
randFloats = randoms (mkStdGen 0)
main = print $ sum $ sort $ take 100 randFloats
Could it be that Data.List.sort is the culprit that uses O(n) stack
space here? If
Bryan O'Sullivan wrote:
Milos Hasan wrote:
so let's say I want to generate a list of N random floats. The elegant
way of doing it would be to create an infinite lazy list of floats and
take the first N, but for N = 1,000,000 or more, this overflows the
stack. The reason is apparently that th
Hi, thanks for the reply..
Hi,
so let's say I want to generate a list of N random floats. The elegant
way of doing it would be to create an infinite lazy list of floats and
take the first N, but for N = 1,000,000 or more, this overflows the
stack. The reason is apparently that the take funct
Milos Hasan wrote:
> so let's say I want to generate a list of N random floats. The elegant
> way of doing it would be to create an infinite lazy list of floats and
> take the first N, but for N = 1,000,000 or more, this overflows the
> stack. The reason is apparently that the take function is not
On Sat, Mar 1, 2008 at 6:50 AM, Milos Hasan <[EMAIL PROTECTED]> wrote:
> Hi,
>
> so let's say I want to generate a list of N random floats. The elegant
> way of doing it would be to create an infinite lazy list of floats and
> take the first N, but for N = 1,000,000 or more, this overflows the
>
Hi,
so let's say I want to generate a list of N random floats. The elegant
way of doing it would be to create an infinite lazy list of floats and
take the first N, but for N = 1,000,000 or more, this overflows the
stack. The reason is apparently that the take function is not
tail-recursive, a
11 matches
Mail list logo