Commit b3ac03eb authored by simonpj@microsoft.com's avatar simonpj@microsoft.com

Remove old, redundant note

parent 1c5fb336
......@@ -208,93 +208,6 @@ which brings appropriate tyvars into scope. This happens for both
<dm-rhs> and for <rhs>, but that doesn't matter: the *renamer* will have
complained if 'b' is mentioned in <rhs>.
Note [Inline dfuns unconditionally]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The code above unconditionally inlines dict funs. Here's why.
Consider this program:
test :: Int -> Int -> Bool
test x y = (x,y) == (y,x) || test y x
-- Recursive to avoid making it inline.
This needs the (Eq (Int,Int)) instance. If we inline that dfun
the code we end up with is good:
Test.$wtest =
\r -> case ==# [ww ww1] of wild {
PrelBase.False -> Test.$wtest ww1 ww;
PrelBase.True ->
case ==# [ww1 ww] of wild1 {
PrelBase.False -> Test.$wtest ww1 ww;
PrelBase.True -> PrelBase.True [];
};
};
Test.test = \r [w w1]
case w of w2 {
PrelBase.I# ww ->
case w1 of w3 { PrelBase.I# ww1 -> Test.$wtest ww ww1; };
};
If we don't inline the dfun, the code is not nearly as good:
(==) = case PrelTup.$fEq(,) PrelBase.$fEqInt PrelBase.$fEqInt of tpl {
PrelBase.:DEq tpl1 tpl2 -> tpl2;
};
Test.$wtest =
\r [ww ww1]
let { y = PrelBase.I#! [ww1]; } in
let { x = PrelBase.I#! [ww]; } in
let { sat_slx = PrelTup.(,)! [y x]; } in
let { sat_sly = PrelTup.(,)! [x y];
} in
case == sat_sly sat_slx of wild {
PrelBase.False -> Test.$wtest ww1 ww;
PrelBase.True -> PrelBase.True [];
};
Test.test =
\r [w w1]
case w of w2 {
PrelBase.I# ww ->
case w1 of w3 { PrelBase.I# ww1 -> Test.$wtest ww ww1; };
};
Why didn't GHC inline $fEq in those days? Because it looked big:
PrelTup.zdfEqZ1T{-rcX-}
= \ @ a{-reT-} :: * @ b{-reS-} :: *
zddEq{-rf6-} _Ks :: {PrelBase.Eq{-23-} a{-reT-}}
zddEq1{-rf7-} _Ks :: {PrelBase.Eq{-23-} b{-reS-}} ->
let {
zeze{-rf0-} _Kl :: (b{-reS-} -> b{-reS-} -> PrelBase.Bool{-3c-})
zeze{-rf0-} = PrelBase.zeze{-01L-}@ b{-reS-} zddEq1{-rf7-} } in
let {
zeze1{-rf3-} _Kl :: (a{-reT-} -> a{-reT-} -> PrelBase.Bool{-3c-})
zeze1{-rf3-} = PrelBase.zeze{-01L-} @ a{-reT-} zddEq{-rf6-} } in
let {
zeze2{-reN-} :: ((a{-reT-}, b{-reS-}) -> (a{-reT-}, b{-reS-})-> PrelBase.Bool{-3c-})
zeze2{-reN-} = \ ds{-rf5-} _Ks :: (a{-reT-}, b{-reS-})
ds1{-rf4-} _Ks :: (a{-reT-}, b{-reS-}) ->
case ds{-rf5-}
of wild{-reW-} _Kd { (a1{-rf2-} _Ks, a2{-reZ-} _Ks) ->
case ds1{-rf4-}
of wild1{-reX-} _Kd { (b1{-rf1-} _Ks, b2{-reY-} _Ks) ->
PrelBase.zaza{-r4e-}
(zeze1{-rf3-} a1{-rf2-} b1{-rf1-})
(zeze{-rf0-} a2{-reZ-} b2{-reY-})
}
} } in
let {
a1{-reR-} :: ((a{-reT-}, b{-reS-})-> (a{-reT-}, b{-reS-})-> PrelBase.Bool{-3c-})
a1{-reR-} = \ a2{-reV-} _Ks :: (a{-reT-}, b{-reS-})
b1{-reU-} _Ks :: (a{-reT-}, b{-reS-}) ->
PrelBase.not{-r6I-} (zeze2{-reN-} a2{-reV-} b1{-reU-})
} in
PrelBase.zdwZCDEq{-r8J-} @ (a{-reT-}, b{-reS-}) a1{-reR-} zeze2{-reN-})
and it's not as bad as it seems, because it's further dramatically
simplified: only zeze2 is extracted and its body is simplified.
%************************************************************************
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment