id	summary	reporter	owner	description	type	status	priority	milestone	component	version	resolution	keywords	cc	os	architecture	failure	difficulty	testcase	blockedby	blocking	related
2078	INLINE and strictness	simonpj	simonpj	"Consider this code 
{{{
module A where
  {-# INLINE [0] foo #-}
  {#- RULE foo (reverse xs) = xs #-}
  foo xs = reverse $ xs

module B where
  import A( foo )
  g b ys = foo (case b of 
                  True -> reverse ys
                  False -> ys)

  h xs = map foo xs
}}}
At the moment the body of `foo` is not optimised at all, because it's going to be inlined.  But that means that

 * The `foo` executed by the `map` in `h` is very inefficient, because it actually calls `$` etc.

 * The strictness analyser doesn't see that `foo` is strict, because again the `$` gets in the way.  So the rule for `foo` does not match in the RHS of `g`.  (If `foo` were strict, we'd push the call to `foo` inside the case branches.)

For both reasons it'd be better to 
  * Retain the original RHS of `foo` for inlining purposes
  * But otherwise optimise `foo` normally, so that if it is not inlined, we get the efficient version, and so that strictness analysis does the right thing.

Hmm.  Maybe INLINE should turn into a RULE, rather than (as now) a `Note` in Core?

Anyway, this ticket is to make sure I don't forget this point.
"	bug	closed	lowest	7.6.1	Compiler	6.8.2	fixed		ndp@…	Unknown/Multiple	Unknown/Multiple	Runtime performance bug	Unknown