Pedro

Some responses to your long message!  (Which I attach for background)

Your example was unusual in that it used a lot of top-level definitions.  GHC treats them slightly specially.  Given:

                x = g 4

                y = f x

GHC does not transform into this:

                y = f (g 4)

which it would do in a nested let.  Why not? Because the latter will generate code that dynamically allocates a thunk for (g 4), while the former will make a static thunk.

(An alternative would be to treat them uniformly and only pull out those nested thunks at the very last minute; but GHC doesn’t do that right now.)

A disadvantage is that it’s not statically visible to the simplifier that x is used once. If we have a RULE for f (g n), it might not fire -- because of the worry that someone else might be sharing x.  

I think this is the root cause of much of your trouble.

Incidentally , it makes no difference giving x an INLINE pragma.   GHC is very cautious about duplicating non-values and currently not even INLINE will make it less cautious.  That’s another thing we could consider changing.

I’ll respond to part 2 (about generic programming) separately

Simon