strictness

I made really time consuming algorithm which produces a short string as the result. When I try to print it (via putStrLn) it appears on the screen character by character. I did understand why that happened, and I tried to force evaluation of the string before actual printing. myPrint !str = putStrLn str But this help very little. When I ran the program in debug I noticed that the !str forced evaluation only for the first character. Does anyone know why is that, and how to deal with this? (!) translates into seq , which evaluates strictly to Weak Head Normal Form -- that is, it only evaluates

Haskell has two left fold functions for lists: foldl , and a "strict" version, foldl' . The problem with the non-strict foldl is that it builds a tower of thunks: foldl (+) 0 [1..5] --> ((((0 + 1) + 2) + 3) + 4) + 5 --> 15 This wastes memory, and may cause a stack overflow if the list has too many items. foldl' , on the other hand, forces the accumulator on every item. However, as far as I can tell, foldl' is semantically equivalent to foldl . Evaluating foldl (+) 0 [1..5] to head normal form requires forcing the accumulator at some point. If we didn't need a head-normal form, we wouldn't be

I'm learning Haskell and currently trying to wrap my head around monads. While playing with some random number generation I got tripped on lazy evaluation once again. In an effort to simplify something close to the: roll :: State StdGen Int roll = do gen <- get let (n, newGen) = randomR (0,1) gen put newGen return n main = do gen <- getStdGen let x = sum $ evalState (replicateM iterations roll) gen print x into something like this: roll' :: IO Int roll' = getStdRandom $ randomR (0,1) main = do x' <- fmap sum $ replicateM iterations roll' print x' on a larger number of iterations , let's say

In Haskell, the term spine strictness is often mentioned in relation to lazy evaluation. Though I have a vague understanding of that it means, it would be nice to have a more concrete explanation about: What is the spine of a data structure What does spine strictness mean? What are the benefits when comparing spine strict data structures with lazy ones? Here's an example > length (undefined : 3 : 4 : undefined : []) 4 > length (2 : 3 : 4 : 5 : undefined) <<loop>> The first list contains bottoms as elements, but the "shape" of the list is fully defined. Roughly speaking, every list cell has a

We all know (or should know) that Haskell is lazy by default. Nothing is evaluated until it must be evaluated. So when must something be evaluated? There are points where Haskell must be strict. I call these "strictness points", although this particular term isn't as widespread as I had thought. According to me: Reduction (or evaluation) in Haskell only occurs at strictness points. So the question is: what, precisely , are Haskell's strictness points? My intuition says that main , seq / bang patterns, pattern matching, and any IO action performed via main are the primary strictness points, but

This may now be a bit fuzzy, but I've been wondering that for a while. To my knowledge with ! , one can make sure a parameter for a data constructor is being evaluated before the value is constructed: data Foo = Bar !Int !Float I have often thought that laziness is a great thing. Now, when I go through sources, I see strict fields more often than the ! -less variant. What is the advantage of this and why shouldn't I leave it lazy as it is? Unless you're storing a large computation in the Int and Float fields, significant overhead can build up from lots of trivial computations building up in

Unboxed types, like Int# , and strict functions, like f (!x) = ... , are something different, but I see conceptual similarity - they disallow thunks/laziness in some way. If Haskell was a strict language like Ocaml, every function would be strict and every type unboxed. What is the relationship between unboxed types and enforcing strictness? Don Stewart Unboxed vs Boxed Data To support parametric polymorphism and laziness , by default Haskell data types are represented uniformly as a pointer to a closure on the heap , with a structure like this: (source: haskell.org ) These are "boxed" values.