INLINE and strictness
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 themap
inh
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 forfoo
does not match in the RHS ofg
. (Iffoo
were strict, we'd push the call tofoo
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.
Trac metadata
Trac field | Value |
---|---|
Version | 6.8.2 |
Type | Bug |
TypeOfFailure | OtherFailure |
Priority | normal |
Resolution | Unresolved |
Component | Compiler |
Test case | |
Differential revisions | |
BlockedBy | |
Related | |
Blocking | |
CC | ndp@cse.unsw.edu.au |
Operating system | Unknown |
Architecture | Unknown |