INLINE and strictness

[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.

[simonpj]

Here's a concrete example when this came up:

Wed Jan 23 16:12:07 PST 2008  Roman Leshchinskiy <rl@cse.unsw.edu.au>
  * Make zipD strict in both arguments

  The strictness analyser doesn't seem to be able to figure this out. This
  change improves fusion.

    M ./Data/Array/Parallel/Unlifted/Distributed/Types.hs -2 +2

[simonpj]

Actually this ticket is implemented, I forget exactly when. INLINE things do capture the RHS in the Unfolding and optimise the RHS separately. Hurrah.