Comments only

diff --git a/compiler/basicTypes/BasicTypes.lhs b/compiler/basicTypes/BasicTypes.lhs
index 15725fd..fa7ead0 100644 (file)
--- a/compiler/basicTypes/BasicTypes.lhs
+++ b/compiler/basicTypes/BasicTypes.lhs
@@ -615,6 +615,8 @@ If you write nothing at all, you get defaultInlinePragma:
 It's not possible to get that combination by *writing* something, so 
 if an Id has defaultInlinePragma it means the user didn't specify anything.
 
+If inl_inline = True, then the Id should have an InlineRule unfolding.
+
 Note [CONLIKE pragma]
 ~~~~~~~~~~~~~~~~~~~~~
 The ConLike constructor of a RuleMatchInfo is aimed at the following.

diff --git a/compiler/coreSyn/CoreSyn.lhs b/compiler/coreSyn/CoreSyn.lhs
index 04d3906..c98fc01 100644 (file)
--- a/compiler/coreSyn/CoreSyn.lhs
+++ b/compiler/coreSyn/CoreSyn.lhs
@@ -645,11 +645,13 @@ When you say
 you intend that calls (f e) are replaced by <rhs>[e/x] So we
 should capture (\x.<rhs>) in the Unfolding of 'f', and never meddle
 with it.  Meanwhile, we can optimise <rhs> to our heart's content,
-leaving the original unfolding intact in Unfolding of 'f'.
+leaving the original unfolding intact in Unfolding of 'f'. For example
+       all xs = foldr (&&) True xs
+       any p = all . map p  {-# INLINE any #-}
+We optimise any's RHS fully, but leave the InlineRule saying "all . map p",
+which deforests well at the call site.
 
-So the representation of an Unfolding has changed quite a bit
-(see CoreSyn).  An INLINE pragma gives rise to an InlineRule 
-unfolding.  
+So INLINE pragma gives rise to an InlineRule, which captures the original RHS.
 
 Moreover, it's only used when 'f' is applied to the
 specified number of arguments; that is, the number of argument on 

diff --git a/compiler/types/Coercion.lhs b/compiler/types/Coercion.lhs
index de310ae..2b0f1b3 100644 (file)
--- a/compiler/types/Coercion.lhs
+++ b/compiler/types/Coercion.lhs
@@ -808,7 +808,7 @@ opt_co_tc_app env sym tc cos
   , let ty = substTy env co2
   = substTyWith [tv] [ty] opt_co1_body -- An inefficient one-variable substitution
 
-  | otherwise    -- Do not push sym inside top-level axioms
+  | otherwise    -- Do *not* push sym inside top-level axioms
                  -- e.g. if g is a top-level axiom
                  --   g a : F a ~ a
                  -- Then (sym (g ty)) /= g (sym ty) !!