What does **Weak Head Normal Form** (WHNF) mean? What does **Head Normal form** (HNF) and **Normal Form** (NF) mean?

[Real World Haskell][1] states:

&gt; The familiar&#160;`seq`&#160;function evaluates an expression to what we
&gt; call&#160;*head normal form*&#160;(abbreviated HNF). It stops once it reaches
&gt; the outermost constructor (the &quot;head&quot;). This is distinct from&#160;*normal
&gt; form*&#160;(NF), in which an expression is completely evaluated.
&gt; 
&gt; You will also hear Haskell programmers refer to&#160;*weak*&#160;head normal
&gt; form (WHNF). For normal data, weak head normal form is the same as
&gt; head normal form. The difference only arises for functions, and is too
&gt; abstruse to concern us here.

I have read a few resources and definitions ([Haskell Wiki][2] and [Haskell Mail List][3] and [Free Dictionary][4]) but I don&#39;t get it. Can someone perhaps give an example or provide a layman definition?

I am guessing it would be similar to:

    WHNF = thunk : thunk
    
    HNF = 0 : thunk 
    
    NF = 0 : 1 : 2 : 3 : []

How do `seq` and `($!)` relate to WHNF and HNF?

Update
------

I am still confused. I know some of the answers say to ignore HNF. From reading the various definitions it seems that there is no difference between regular data in WHNF and HNF. However, it does seem like there is a difference when it comes to a function. If there was no difference, why is `seq` necessary for `foldl&#39;`?

Another point of confusion is from the Haskell Wiki, which states that `seq` reduces to WHNF, and will do nothing to the following example. Then they say that they have to use `seq` to force the evaluation. Is that not forcing it to HNF?

&gt; Common newbie stack overflowing code:
&gt;
&gt;     myAverage = uncurry (/) . foldl&#39; (\(acc, len) x -&gt; (acc+x, len+1)) (0,0)
&gt;
&gt; People who understand seq and weak head normal form (whnf) can immediately understand what goes wrong here.&#160;`(acc+x,&#160;len+1)`&#160;is already in whnf, so the&#160;`seq`&#160;(in the definition of&#160;`foldl&#39;`), which reduces a value to whnf, does nothing to this. This code will build up thunks just like the original&#160;`foldl`&#160;example, they&#39;ll just be inside a tuple. The solution is just to force the
&gt; components of the tuple,  e.g.
&gt;
&gt;     myAverage = uncurry (/) . foldl&#39; 
&gt;               (\(acc, len) x -&gt; acc `seq` len `seq` (acc+x, len+1)) (0,0)

-[Haskell Wiki on Stackoverflow][5]


  [1]: http://book.realworldhaskell.org/read/concurrent-and-multicore-programming.html
  [2]: http://en.wikibooks.org/wiki/Haskell/Graph_reduction#Weak_Head_Normal_Form
  [3]: http://www.haskell.org/pipermail/beginners/2010-February/003396.html
  [4]: http://encyclopedia2.thefreedictionary.com/Weak+Head+Normal+Form
  [5]: http://www.haskell.org/haskellwiki/Stack_overflow

All Weak Head-Normal-Form Solutions on Gang of Coders

Total of 1 Weak Head-Normal-Form Solutions

What is Weak Head Normal Form?