I'm new to Haskell and trying to get a better understanding of sharing (and ultimately memoization).  I've read SOE and various of the tutorials, as well as browsing around the wiki and old mailing lists. 

 

Most of the examples of memoization seem to revolve around Fibonacci, and are based either on the fact that a list defined within the function will get shared between calls, or on doing some 'unsafeIO' (which I haven't dug too deeply into.)  

 

I've read various discussions that explain why function calls are generally not automatically memoized (e.g. f x  gets recalculated rather than looked up based on the prior result).  The rationale for that (big space leak and no guarantee of improved performance) makes sense.  (Though I did like one poster's suggestion of a compiler pragma that hints that a particular function should be memoized.)

 

I've seen other discussions that suggest that lists are always shared while in scope (so the fibs trick works).  But is that just a feature of the standard compilers, or is it somewhere mandated in the Hakell spec (I don't see anything obvious in the Haskell Report tho haven't read it cover to cover)?

 

The wiki page http://www.haskell.org/haskellwiki/Performance/Strictness  says laziness == non-strictness + sharing but again nowhere gives a set of rules that guarantees what will be shared and what won't.  I was hoping I might find it here: http://www.haskell.org/haskellwiki/Sharing but no such luck.  Or are there no guarantees and you just have to know how your particular compiler works??

 

Cheers,

Patrick