On Dienstag, 25. Dezember 2012, 20:00:18, Emmanuel Touzery wrote:

Hello,

On Tue, Dec 25, 2012 at 3:39 PM, Daniel Fischer <

daniel.is.fischer@googlemail.com> wrote:

...

Defining TvShow with strict fields for title, startTime and summary makes sure these fields are evaluated (to WHNF, but in case of `Data.Text`, that means fully evaluated) **when the TvShow value is evaluated to WHNF**.

how do I know what does "evaluated to WHNF" means for every possible type?

For non-function types, it means evaluate until the outermost constructor is known. For function types (which have no constructors), it means evaluating to the outermost lambda.

For instance, what does that mean for "String"?

String is a list, so there it means evaluate until it is known whether the value is [] or (_:_). In particular, characters (or generally list elements) are only evaluated if that is necessary to determine whether the list is empty or not. If `dropWhile isSpace someString` is evaluated to WHNF, the characters in someString must be evaluated until the first non-space character is found (or the end of someString is reached, or a _|_ is reached) since that is necessary to find the outermost constructor. So evaluating dropWhile isSpace [' ' .. ] to WHNF produces ('!':_) and not only (_:_)

What does that mean for "Maybe String"?

Find out whether it's a `Just someThing` or `Nothing`. Again, in the case of a `Just someThing`, the someThing is only evaluated if that's necessary to find out whether it's a `Just` at all.

If I want the field to be fully evaluated, is !(Maybe String) enough or should I even do !(Maybe !String) or something more?

You can't have something like Maybe !String `!String' is not a type, so it's not an allowed argument for `Maybe'. A field `field :: !(Maybe String)' would only force evaluation of the `Maybe' constructor when the containing value is evaluated, the String in a `Just' would still remain completely unevaluated (unless that is necessary to find out whether the `Maybe String' value is a `Just'). You can define a strict version of `Maybe`, data SMaybe a = SJust !a | SNothing and have a field `field :: !(SMaybe String)'. But that would still only evaluate the String to WHNF, so `SJust (undefined : undefined)' is still possible. If you want complete evaluation, you need to recur through every type adding a constructor layer, until you reach a function type or a base case (enumerations data Foo = Bar | Baz | Quux and wrappers of primitive types like data Int = I# Int# [for GHC]).

Any source of information where I can read about this in depth would be welcome (I have yet to read Real World Haskell, maybe it's covered there?).

I don't know to what depth it is covered in RWH, it must be covered in some depth there. And there's of course the invaluable and authoritative language report http://www.haskell.org/onlinereport/haskell2010/ Cheers, Daniel