I'd like to see a way of enforcing return strictness, that is where you have confidence that what a function is returning is fully evaluated. Imagine a function hstrict; hstrict :: a -> a you can define hseq with this. hseq :: a -> b -> b hseq a b = hstrict a `seq` b and $!!. ($!!) :: (a -> b) -> a -> b a $!! b = a $! (hstrict b) With hstrict you can write functions in the style. fun f a b c = hstrict $ .... where ... ... and also fun f a b c = hstruct $ bla { abc = def , cfg = tts , ... } We know that strictness plays no part in the returned value after the function is finished evaluating, which is a Useful Property. What I'd like is a efficient hstrict, that does not re-evaluate anything that has already been hstrict-ified. In the same way as we evaluate an object, we could strictify an object using a similar (low-level) mechanism. So the cost of calling hstrict would be amortized away to almost nothing. How much work would this be to add hstrict GHC? A extra bit in the runtime representation? Could we use the speculation mechanism to do it? Andy Gill