Core Lint error when deriving Ix/Enum instances in separate TyClGroups
The following program will throw a Core Lint error when compiled with GHC 8.4.4 or later:
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TemplateHaskell #-}
module Bug where
import Data.Ix
data T = MkT deriving (Eq, Ord, Ix)
$(return [])
deriving instance Enum T
$ /opt/ghc/8.10.1/bin/ghc Bug.hs -dcore-lint -fforce-recomp
[1 of 1] Compiling Bug ( Bug.hs, Bug.o, Bug.dyn_o )
*** Core Lint errors : in result of Desugar (before optimization) ***
<no location info>: warning:
Duplicate variables brought into scope
[[$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi,
$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi],
[$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi, $tag2con_Gy9uKLgm4jJ6VNSWrwZmPi],
[$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi, $maxtag_Gy9uKLgm4jJ6VNSWrwZmPi]]
Substitution: [TCvSubst
In scope: InScope {$c==_a15C $c/=_a1j4 $cp1Ord_a1je $ccompare_a1jg
$c<_a1jr $c<=_a1jz $c>_a1jF $c>=_a1jL $cmax_a1jS $cmin_a1jZ
$cp1Ix_a1k9 $crange_a1kb $cindex_a1oX $cunsafeIndex_a1p3
$cinRange_a1pd $crangeSize_a1po $cunsafeRangeSize_a1pv
$csucc_a31k $cpred_a339 $ctoEnum_a33m $cfromEnum_a3aa
$cenumFrom_a3ag $cenumFromThen_a3aq $cenumFromTo_a3aF
$cenumFromThenTo_a3aM $krep_a3bn $tc'MkT $tcT $fEqT $fOrdT
$fIxT $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi
$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi $fEnumT $trModule}
Type env: []
Co env: []]
Here is the full Core Lint error:
$ /opt/ghc/8.10.1/bin/ghc Bug.hs -dcore-lint -fforce-recomp
[1 of 1] Compiling Bug ( Bug.hs, Bug.o, Bug.dyn_o )
*** Core Lint errors : in result of Desugar (before optimization) ***
<no location info>: warning:
Duplicate variables brought into scope
[[$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi,
$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi],
[$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi, $tag2con_Gy9uKLgm4jJ6VNSWrwZmPi],
[$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi, $maxtag_Gy9uKLgm4jJ6VNSWrwZmPi]]
Substitution: [TCvSubst
In scope: InScope {$c==_a15C $c/=_a1j4 $cp1Ord_a1je $ccompare_a1jg
$c<_a1jr $c<=_a1jz $c>_a1jF $c>=_a1jL $cmax_a1jS $cmin_a1jZ
$cp1Ix_a1k9 $crange_a1kb $cindex_a1oX $cunsafeIndex_a1p3
$cinRange_a1pd $crangeSize_a1po $cunsafeRangeSize_a1pv
$csucc_a31k $cpred_a339 $ctoEnum_a33m $cfromEnum_a3aa
$cenumFrom_a3ag $cenumFromThen_a3aq $cenumFromTo_a3aF
$cenumFromThenTo_a3aM $krep_a3bn $tc'MkT $tcT $fEqT $fOrdT
$fIxT $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi
$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi $fEnumT $trModule}
Type env: []
Co env: []]
*** Offending Program ***
Rec {
$tcT :: TyCon
[LclIdX]
$tcT
= TyCon
3434200769789901771##
7420687037569213068##
$trModule
(TrNameS "T"#)
0#
krep$*
$tc'MkT :: TyCon
[LclIdX]
$tc'MkT
= TyCon
14327102274620998837##
8004000512705792002##
$trModule
(TrNameS "'MkT"#)
0#
$krep_a3bn
$krep_a3bn [InlPrag=NOUSERINLINE[~]] :: KindRep
[LclId]
$krep_a3bn = KindRepTyConApp $tcT ([] @ KindRep)
$trModule :: Module
[LclIdX]
$trModule = Module (TrNameS "main"#) (TrNameS "Bug"#)
$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi :: Int
[LclId]
$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi = I# 0#
$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi :: Int -> T
[LclId]
$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
= \ (ds_d3bo :: Int) ->
case ds_d3bo of wild_00 { I# a_a30Q -> tagToEnum# @ T a_a30Q }
$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi :: T -> Int#
[LclId]
$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi
= \ (ds_d3bp :: T) -> case ds_d3bp of wild_00 { MkT -> 0# }
$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi :: Int
[LclId]
$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi = I# 0#
$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi :: Int -> T
[LclId]
$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
= \ (ds_d3bq :: Int) ->
case ds_d3bq of wild_00 { I# a_a14V -> tagToEnum# @ T a_a14V }
$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi :: T -> Int#
[LclId]
$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi
= \ (ds_d3br :: T) -> case ds_d3br of wild_00 { MkT -> 0# }
$fEqT [InlPrag=NOUSERINLINE CONLIKE] :: Eq T
[LclIdX[DFunId], Unf=DFun: \ -> C:Eq TYPE: T $c==_a15C $c/=_a1j4]
$fEqT = C:Eq @ T $c==_a15C $c/=_a1j4
$c==_a15C :: T -> T -> Bool
[LclId]
$c==_a15C
= \ (ds_d3bs :: T) (ds_d3bt :: T) ->
case ds_d3bs of wild_00 { MkT ->
case ds_d3bt of wild_00 { MkT -> True }
}
$c/=_a1j4 :: T -> T -> Bool
[LclId]
$c/=_a1j4
= let {
$dEq_a1j8 :: Eq T
[LclId]
$dEq_a1j8 = $fEqT } in
$dm/= @ T $dEq_a1j8
$fOrdT [InlPrag=NOUSERINLINE CONLIKE] :: Ord T
[LclIdX[DFunId],
Unf=DFun: \ ->
C:Ord TYPE: T
$cp1Ord_a1je
$ccompare_a1jg
$c<_a1jr
$c<=_a1jz
$c>_a1jF
$c>=_a1jL
$cmax_a1jS
$cmin_a1jZ]
$fOrdT
= C:Ord
@ T
$cp1Ord_a1je
$ccompare_a1jg
$c<_a1jr
$c<=_a1jz
$c>_a1jF
$c>=_a1jL
$cmax_a1jS
$cmin_a1jZ
$cp1Ord_a1je :: Eq T
[LclId]
$cp1Ord_a1je
= let {
$dEq_a1jc :: Eq T
[LclId]
$dEq_a1jc = $fEqT } in
let {
$dEq_a1jf :: Eq T
[LclId]
$dEq_a1jf = $dEq_a1jc } in
$dEq_a1jf
$ccompare_a1jg :: T -> T -> Ordering
[LclId]
$ccompare_a1jg
= \ (a_a14W :: T) (b_a14X :: T) ->
let {
ds_d3bu :: T
[LclId]
ds_d3bu = a_a14W } in
case ds_d3bu of wild_00 { MkT ->
let {
ds_d3bv :: T
[LclId]
ds_d3bv = b_a14X } in
case ds_d3bv of wild_00 { MkT -> EQ }
}
$c<_a1jr :: T -> T -> Bool
[LclId]
$c<_a1jr
= \ (a_a14Y :: T) (b_a14Z :: T) ->
let {
ds_d3bw :: T
[LclId]
ds_d3bw = a_a14Y } in
case ds_d3bw of wild_00 { MkT ->
let {
ds_d3bx :: T
[LclId]
ds_d3bx = b_a14Z } in
case ds_d3bx of wild_00 { MkT -> False }
}
$c<=_a1jz :: T -> T -> Bool
[LclId]
$c<=_a1jz
= let {
$dOrd_a1jD :: Ord T
[LclId]
$dOrd_a1jD = $fOrdT } in
\ (a_a150 :: T) (b_a151 :: T) ->
not (< @ T $dOrd_a1jD b_a151 a_a150)
$c>_a1jF :: T -> T -> Bool
[LclId]
$c>_a1jF
= let {
$dOrd_a1jJ :: Ord T
[LclId]
$dOrd_a1jJ = $fOrdT } in
\ (a_a152 :: T) (b_a153 :: T) -> < @ T $dOrd_a1jJ b_a153 a_a152
$c>=_a1jL :: T -> T -> Bool
[LclId]
$c>=_a1jL
= let {
$dOrd_a1jP :: Ord T
[LclId]
$dOrd_a1jP = $fOrdT } in
\ (a_a154 :: T) (b_a155 :: T) ->
not (< @ T $dOrd_a1jP a_a154 b_a155)
$cmax_a1jS :: T -> T -> T
[LclId]
$cmax_a1jS
= let {
$dOrd_a1jW :: Ord T
[LclId]
$dOrd_a1jW = $fOrdT } in
$dmmax @ T $dOrd_a1jW
$cmin_a1jZ :: T -> T -> T
[LclId]
$cmin_a1jZ
= let {
$dOrd_a1k3 :: Ord T
[LclId]
$dOrd_a1k3 = $fOrdT } in
$dmmin @ T $dOrd_a1k3
$fIxT [InlPrag=NOUSERINLINE CONLIKE] :: Ix T
[LclIdX[DFunId],
Unf=DFun: \ ->
C:Ix TYPE: T
$cp1Ix_a1k9
$crange_a1kb
$cindex_a1oX
$cunsafeIndex_a1p3
$cinRange_a1pd
$crangeSize_a1po
$cunsafeRangeSize_a1pv]
$fIxT
= C:Ix
@ T
$cp1Ix_a1k9
$crange_a1kb
$cindex_a1oX
$cunsafeIndex_a1p3
$cinRange_a1pd
$crangeSize_a1po
$cunsafeRangeSize_a1pv
$cp1Ix_a1k9 :: Ord T
[LclId]
$cp1Ix_a1k9
= let {
$dOrd_a1k7 :: Ord T
[LclId]
$dOrd_a1k7 = $fOrdT } in
let {
$dOrd_a1ka :: Ord T
[LclId]
$dOrd_a1ka = $dOrd_a1k7 } in
$dOrd_a1ka
$crange_a1kb :: (T, T) -> [T]
[LclId]
$crange_a1kb
= let {
$dEnum_a1oU :: Enum Int
[LclId]
$dEnum_a1oU = $fEnumInt } in
\ (ds_d3by :: (T, T)) ->
case ds_d3by of wild_00 { (a_a156, b_a157) ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a156 of a#_a158
{ __DEFAULT ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi b_a157 of b#_a159
{ __DEFAULT ->
map
@ Int
@ T
$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
(enumFromTo @ Int $dEnum_a1oU (I# a#_a158) (I# b#_a159))
}
}
}
$cindex_a1oX :: (T, T) -> T -> Int
[LclId]
$cindex_a1oX
= let {
$dIx_a1p1 :: Ix T
[LclId]
$dIx_a1p1 = $fIxT } in
$dmindex @ T $dIx_a1p1
$cunsafeIndex_a1p3 :: (T, T) -> T -> Int
[LclId]
$cunsafeIndex_a1p3
= \ (c_a15a :: (T, T)) (d_a15c :: T) ->
case c_a15a of wild_00 { (a_a15b, ds_d3bz) ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a15b of a#_a15d
{ __DEFAULT ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi d_a15c of d#_a15e
{ __DEFAULT ->
let {
c_a15f :: Int#
[LclId]
c_a15f = -# d#_a15e a#_a15d } in
I# c_a15f
}
}
}
$cinRange_a1pd :: (T, T) -> T -> Bool
[LclId]
$cinRange_a1pd
= \ (ds_d3bA :: (T, T)) (c_a15i :: T) ->
case ds_d3bA of wild_00 { (a_a15g, b_a15h) ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a15g of a#_a15j
{ __DEFAULT ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi b_a15h of b#_a15k
{ __DEFAULT ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi c_a15i of c#_a15l
{ __DEFAULT ->
&&
(tagToEnum# @ Bool (>=# c#_a15l a#_a15j))
(tagToEnum# @ Bool (<=# c#_a15l b#_a15k))
}
}
}
}
$crangeSize_a1po :: (T, T) -> Int
[LclId]
$crangeSize_a1po
= let {
$dIx_a1ps :: Ix T
[LclId]
$dIx_a1ps = $fIxT } in
$dmrangeSize @ T $dIx_a1ps
$cunsafeRangeSize_a1pv :: (T, T) -> Int
[LclId]
$cunsafeRangeSize_a1pv
= let {
$dIx_a1pz :: Ix T
[LclId]
$dIx_a1pz = $fIxT } in
$dmunsafeRangeSize @ T $dIx_a1pz
$fEnumT [InlPrag=NOUSERINLINE CONLIKE] :: Enum T
[LclIdX[DFunId],
Unf=DFun: \ ->
C:Enum TYPE: T
$csucc_a31k
$cpred_a339
$ctoEnum_a33m
$cfromEnum_a3aa
$cenumFrom_a3ag
$cenumFromThen_a3aq
$cenumFromTo_a3aF
$cenumFromThenTo_a3aM]
$fEnumT
= C:Enum
@ T
$csucc_a31k
$cpred_a339
$ctoEnum_a33m
$cfromEnum_a3aa
$cenumFrom_a3ag
$cenumFromThen_a3aq
$cenumFromTo_a3aF
$cenumFromThenTo_a3aM
$csucc_a31k :: T -> T
[LclId]
$csucc_a31k
= let {
$dIP_a3aX :: ?callStack::CallStack
[LclId]
$dIP_a3aX
= emptyCallStack
`cast` (Sym (N:IP[0] <"callStack">_N <CallStack>_N)
:: CallStack ~R# (?callStack::CallStack)) } in
let {
$dNum_a337 :: Num Int
[LclId]
$dNum_a337 = $fNumInt } in
let {
$dIP_a32q :: HasCallStack
[LclId]
$dIP_a32q
= (pushCallStack
(unpackCString# "error"#,
SrcLoc
(unpackCString# "main"#)
(unpackCString# "Bug"#)
(unpackCString# "Bug.hs"#)
(I# 9#)
(I# 1#)
(I# 9#)
(I# 25#))
($dIP_a3aX
`cast` (N:IP[0] <"callStack">_N <CallStack>_N
:: (?callStack::CallStack) ~R# CallStack)))
`cast` (Sym (N:IP[0] <"callStack">_N <CallStack>_N)
:: CallStack ~R# (?callStack::CallStack)) } in
let {
$dEq_a31q :: Eq Int
[LclId]
$dEq_a31q = $fEqInt } in
\ (a_a30R :: T) ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a30R of a#_a30S
{ __DEFAULT ->
case == @ Int $dEq_a31q $maxtag_Gy9uKLgm4jJ6VNSWrwZmPi (I# a#_a30S)
of wild_00 {
False ->
$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
(+ @ Int $dNum_a337 (I# a#_a30S) (I# 1#));
True ->
error
@ 'LiftedRep
@ T
$dIP_a32q
(unpackCString#
"succ{T}: tried to take `succ' of last tag in enumeration"#)
}
}
$cpred_a339 :: T -> T
[LclId]
$cpred_a339
= let {
$dIP_a3b3 :: ?callStack::CallStack
[LclId]
$dIP_a3b3
= emptyCallStack
`cast` (Sym (N:IP[0] <"callStack">_N <CallStack>_N)
:: CallStack ~R# (?callStack::CallStack)) } in
let {
$dNum_a33k :: Num Int
[LclId]
$dNum_a33k = $fNumInt } in
let {
$dIP_a33i :: HasCallStack
[LclId]
$dIP_a33i
= (pushCallStack
(unpackCString# "error"#,
SrcLoc
(unpackCString# "main"#)
(unpackCString# "Bug"#)
(unpackCString# "Bug.hs"#)
(I# 9#)
(I# 1#)
(I# 9#)
(I# 25#))
($dIP_a3b3
`cast` (N:IP[0] <"callStack">_N <CallStack>_N
:: (?callStack::CallStack) ~R# CallStack)))
`cast` (Sym (N:IP[0] <"callStack">_N <CallStack>_N)
:: CallStack ~R# (?callStack::CallStack)) } in
let {
$dEq_a33f :: Eq Int
[LclId]
$dEq_a33f = $fEqInt } in
\ (a_a30T :: T) ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a30T of a#_a30U
{ __DEFAULT ->
case == @ Int $dEq_a33f (I# 0#) (I# a#_a30U) of wild_00 {
False ->
$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
(+ @ Int $dNum_a33k (I# a#_a30U) (I# -1#));
True ->
error
@ 'LiftedRep
@ T
$dIP_a33i
(unpackCString#
"pred{T}: tried to take `pred' of first tag in enumeration"#)
}
}
$ctoEnum_a33m :: Int -> T
[LclId]
$ctoEnum_a33m
= let {
$dIP_a3b4 :: ?callStack::CallStack
[LclId]
$dIP_a3b4
= emptyCallStack
`cast` (Sym (N:IP[0] <"callStack">_N <CallStack>_N)
:: CallStack ~R# (?callStack::CallStack)) } in
let {
$dShow_a3a5 :: Show Int
[LclId]
$dShow_a3a5 = $fShowInt } in
let {
$dShow_a3a8 :: Show Int
[LclId]
$dShow_a3a8 = $dShow_a3a5 } in
let {
$dIP_a33v :: HasCallStack
[LclId]
$dIP_a33v
= (pushCallStack
(unpackCString# "error"#,
SrcLoc
(unpackCString# "main"#)
(unpackCString# "Bug"#)
(unpackCString# "Bug.hs"#)
(I# 9#)
(I# 1#)
(I# 9#)
(I# 25#))
($dIP_a3b4
`cast` (N:IP[0] <"callStack">_N <CallStack>_N
:: (?callStack::CallStack) ~R# CallStack)))
`cast` (Sym (N:IP[0] <"callStack">_N <CallStack>_N)
:: CallStack ~R# (?callStack::CallStack)) } in
let {
$dOrd_a33q :: Ord Int
[LclId]
$dOrd_a33q = $fOrdInt } in
let {
$dOrd_a33s :: Ord Int
[LclId]
$dOrd_a33s = $dOrd_a33q } in
\ (a_a30V :: Int) ->
case &&
(>= @ Int $dOrd_a33q a_a30V (I# 0#))
(<= @ Int $dOrd_a33s a_a30V $maxtag_Gy9uKLgm4jJ6VNSWrwZmPi)
of wild_00 {
False ->
error
@ 'LiftedRep
@ T
$dIP_a33v
(++
@ Char
(unpackCString# "toEnum{T}: tag ("#)
(showsPrec
@ Int
$dShow_a3a5
(I# 0#)
a_a30V
(++
@ Char
(unpackCString# ") is outside of enumeration's range (0,"#)
(showsPrec
@ Int
$dShow_a3a8
(I# 0#)
$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi
(unpackCString# ")"#)))));
True -> $tag2con_Gy9uKLgm4jJ6VNSWrwZmPi a_a30V
}
$cfromEnum_a3aa :: T -> Int
[LclId]
$cfromEnum_a3aa
= \ (a_a312 :: T) ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a312 of a#_a313
{ __DEFAULT ->
I# a#_a313
}
$cenumFrom_a3ag :: T -> [T]
[LclId]
$cenumFrom_a3ag
= let {
$dEnum_a3ao :: Enum Int
[LclId]
$dEnum_a3ao = $fEnumInt } in
\ (a_a30W :: T) ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a30W of a#_a30X
{ __DEFAULT ->
map
@ Int
@ T
$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
(enumFromTo
@ Int $dEnum_a3ao (I# a#_a30X) $maxtag_Gy9uKLgm4jJ6VNSWrwZmPi)
}
$cenumFromThen_a3aq :: T -> T -> [T]
[LclId]
$cenumFromThen_a3aq
= let {
$dOrd_a3aC :: Ord Int
[LclId]
$dOrd_a3aC = $fOrdInt } in
let {
$dEnum_a3aA :: Enum Int
[LclId]
$dEnum_a3aA = $fEnumInt } in
\ (a_a30Y :: T) (b_a30Z :: T) ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a30Y of a#_a310
{ __DEFAULT ->
case $con2tag_Gy9uKLgm4jJ6VNSWrwZmPi b_a30Z of b#_a311
{ __DEFAULT ->
map
@ Int
@ T
$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
(enumFromThenTo
@ Int
$dEnum_a3aA
(I# a#_a310)
(I# b#_a311)
(case > @ Int $dOrd_a3aC (I# a#_a310) (I# b#_a311) of wild_00 {
False -> $maxtag_Gy9uKLgm4jJ6VNSWrwZmPi;
True -> I# 0#
}))
}
}
$cenumFromTo_a3aF :: T -> T -> [T]
[LclId]
$cenumFromTo_a3aF
= let {
$dEnum_a3aJ :: Enum T
[LclId]
$dEnum_a3aJ = $fEnumT } in
$dmenumFromTo @ T $dEnum_a3aJ
$cenumFromThenTo_a3aM :: T -> T -> T -> [T]
[LclId]
$cenumFromThenTo_a3aM
= let {
$dEnum_a3aQ :: Enum T
[LclId]
$dEnum_a3aQ = $fEnumT } in
$dmenumFromThenTo @ T $dEnum_a3aQ
end Rec }
*** End of Offense ***
<no location info>: error:
Compilation had errors
The reason this happens is that both deriving Ix
and deriving Enum
generate auxiliary functions named con2tag_Gy9uKLgm4jJ6VNSWrwZmPi
, tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
, and maxtag_Gy9uKLgm4jJ6VNSWrwZmPi
. As long as the two deriving
declarations are contained in the same TyClGroup
, these generated auxiliary functions will only be defined once and will be shared between the derived Ix
and Enum
instances. If the two deriving
declarations put into separate TyClGroup
s, as in the example above, then each function is defined twice. This can be seen by inspecting the -ddump-deriv
output:
$ /opt/ghc/8.10.1/bin/ghc Bug.hs -ddump-deriv -fforce-recomp
[1 of 1] Compiling Bug ( Bug.hs, Bug.o, Bug.dyn_o )
==================== Derived instances ====================
Derived class instances:
instance GHC.Classes.Eq Bug.T where
(GHC.Classes.==) (Bug.MkT) (Bug.MkT) = GHC.Types.True
instance GHC.Classes.Ord Bug.T where
GHC.Classes.compare a_a14W b_a14X
= case a_a14W of {
Bug.MkT -> case b_a14X of { Bug.MkT -> GHC.Types.EQ } }
(GHC.Classes.<) a_a14Y b_a14Z
= case a_a14Y of {
Bug.MkT -> case b_a14Z of { Bug.MkT -> GHC.Types.False } }
(GHC.Classes.<=) a_a150 b_a151
= GHC.Classes.not ((GHC.Classes.<) b_a151 a_a150)
(GHC.Classes.>) a_a152 b_a153 = (GHC.Classes.<) b_a153 a_a152
(GHC.Classes.>=) a_a154 b_a155
= GHC.Classes.not ((GHC.Classes.<) a_a154 b_a155)
instance GHC.Ix.Ix Bug.T where
GHC.Ix.range (a_a156, b_a157)
= case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a156) of {
a#_a158
-> case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi b_a157) of {
b#_a159
-> GHC.Base.map
Bug.$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
(GHC.Enum.enumFromTo
(GHC.Types.I# a#_a158) (GHC.Types.I# b#_a159)) } }
GHC.Ix.unsafeIndex c_a15a@(a_a15b, _) d_a15c
= case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a15b) of {
a#_a15d
-> case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi d_a15c) of {
d#_a15e
-> case (d#_a15e GHC.Prim.-# a#_a15d) of {
c_a15f -> GHC.Types.I# c_a15f } } }
GHC.Ix.inRange (a_a15g, b_a15h) c_a15i
= case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a15g) of {
a#_a15j
-> case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi b_a15h) of {
b#_a15k
-> case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi c_a15i) of {
c#_a15l
-> (GHC.Classes.&&)
(GHC.Prim.tagToEnum# (c#_a15l GHC.Prim.>=# a#_a15j))
(GHC.Prim.tagToEnum# (c#_a15l GHC.Prim.<=# b#_a15k)) } } }
Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi :: Bug.T -> GHC.Prim.Int#
Bug.$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi :: GHC.Types.Int -> Bug.T
Bug.$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi :: GHC.Types.Int
Bug.$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi = GHC.Types.I# 0#
Bug.$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi (GHC.Types.I# a_a14V)
= GHC.Prim.tagToEnum# a_a14V
Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi Bug.MkT = 0#
Derived type family instances:
==================== Filling in method body ====================
GHC.Classes.Eq [Bug.T]
GHC.Classes./= = GHC.Classes.$dm/= @(Bug.T)
==================== Filling in method body ====================
GHC.Classes.Ord [Bug.T]
GHC.Classes.max = GHC.Classes.$dmmax @(Bug.T)
==================== Filling in method body ====================
GHC.Classes.Ord [Bug.T]
GHC.Classes.min = GHC.Classes.$dmmin @(Bug.T)
==================== Filling in method body ====================
GHC.Ix.Ix [Bug.T]
GHC.Ix.index = GHC.Ix.$dmindex @(Bug.T)
==================== Filling in method body ====================
GHC.Ix.Ix [Bug.T]
GHC.Ix.rangeSize = GHC.Ix.$dmrangeSize @(Bug.T)
==================== Filling in method body ====================
GHC.Ix.Ix [Bug.T]
GHC.Ix.unsafeRangeSize = GHC.Ix.$dmunsafeRangeSize @(Bug.T)
==================== Derived instances ====================
Derived class instances:
instance GHC.Enum.Enum Bug.T where
GHC.Enum.succ a_a30R
= case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a30R) of {
a#_a30S
-> if (GHC.Classes.==)
Bug.$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi (GHC.Types.I# a#_a30S) then
GHC.Err.error
"succ{T}: tried to take `succ' of last tag in enumeration"
else
Bug.$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
((GHC.Num.+) (GHC.Types.I# a#_a30S) 1) }
GHC.Enum.pred a_a30T
= case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a30T) of {
a#_a30U
-> if (GHC.Classes.==) 0 (GHC.Types.I# a#_a30U) then
GHC.Err.error
"pred{T}: tried to take `pred' of first tag in enumeration"
else
Bug.$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
((GHC.Num.+) (GHC.Types.I# a#_a30U) (-1)) }
GHC.Enum.toEnum a_a30V
= if (GHC.Classes.&&)
((GHC.Classes.>=) a_a30V 0)
((GHC.Classes.<=) a_a30V Bug.$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi) then
Bug.$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi a_a30V
else
GHC.Err.error
((GHC.Base.++)
"toEnum{T}: tag ("
(GHC.Show.showsPrec
0 a_a30V
((GHC.Base.++)
") is outside of enumeration's range (0,"
(GHC.Show.showsPrec 0 Bug.$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi ")"))))
GHC.Enum.enumFrom a_a30W
= case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a30W) of {
a#_a30X
-> GHC.Base.map
Bug.$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
(GHC.Enum.enumFromTo
(GHC.Types.I# a#_a30X) Bug.$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi) }
GHC.Enum.enumFromThen a_a30Y b_a30Z
= case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a30Y) of {
a#_a310
-> case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi b_a30Z) of {
b#_a311
-> GHC.Base.map
Bug.$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi
(GHC.Enum.enumFromThenTo
(GHC.Types.I# a#_a310) (GHC.Types.I# b#_a311)
(if (GHC.Classes.>)
(GHC.Types.I# a#_a310) (GHC.Types.I# b#_a311) then
0
else
Bug.$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi)) } }
GHC.Enum.fromEnum a_a312
= case (Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi a_a312) of {
a#_a313 -> GHC.Types.I# a#_a313 }
Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi :: Bug.T -> GHC.Prim.Int#
Bug.$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi :: GHC.Types.Int -> Bug.T
Bug.$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi :: GHC.Types.Int
Bug.$maxtag_Gy9uKLgm4jJ6VNSWrwZmPi = GHC.Types.I# 0#
Bug.$tag2con_Gy9uKLgm4jJ6VNSWrwZmPi (GHC.Types.I# a_a30Q)
= GHC.Prim.tagToEnum# a_a30Q
Bug.$con2tag_Gy9uKLgm4jJ6VNSWrwZmPi Bug.MkT = 0#
Derived type family instances:
==================== Filling in method body ====================
GHC.Enum.Enum [Bug.T]
GHC.Enum.enumFromTo = GHC.Enum.$dmenumFromTo @(Bug.T)
==================== Filling in method body ====================
GHC.Enum.Enum [Bug.T]
GHC.Enum.enumFromThenTo = GHC.Enum.$dmenumFromThenTo @(Bug.T)