singletons-2.4: tests/compile-and-dump/Singletons/T159.ghc84.template
Singletons/T159.hs:0:0:: Splicing declarations
genSingletons [''T0, ''T1]
======>
type ASym0 = A
type BSym0 = B
type CSym0 = C
type DSym0 = D
type ESym0 = E
type FSym0 = F
data instance Sing (z :: T0)
where
SA :: Sing A
SB :: Sing B
SC :: Sing C
SD :: Sing D
SE :: Sing E
SF :: Sing F
type ST0 = (Sing :: T0 -> GHC.Types.Type)
instance SingKind T0 where
type Demote T0 = T0
fromSing SA = A
fromSing SB = B
fromSing SC = C
fromSing SD = D
fromSing SE = E
fromSing SF = F
toSing A = SomeSing SA
toSing B = SomeSing SB
toSing C = SomeSing SC
toSing D = SomeSing SD
toSing E = SomeSing SE
toSing F = SomeSing SF
instance SingI A where
sing = SA
instance SingI B where
sing = SB
instance SingI C where
sing = SC
instance SingI D where
sing = SD
instance SingI E where
sing = SE
instance SingI F where
sing = SF
type N1Sym0 = N1
type C1Sym2 (t :: T0) (t :: T1) = C1 t t
instance SuppressUnusedWarnings C1Sym1 where
suppressUnusedWarnings
= snd ((GHC.Tuple.(,) C1Sym1KindInference) GHC.Tuple.())
data C1Sym1 (l :: T0) (l :: TyFun T1 T1)
= forall arg. SameKind (Apply (C1Sym1 l) arg) (C1Sym2 l arg) =>
C1Sym1KindInference
type instance Apply (C1Sym1 l) l = C1 l l
instance SuppressUnusedWarnings C1Sym0 where
suppressUnusedWarnings
= snd ((GHC.Tuple.(,) C1Sym0KindInference) GHC.Tuple.())
data C1Sym0 (l :: TyFun T0 (TyFun T1 T1 -> GHC.Types.Type))
= forall arg. SameKind (Apply C1Sym0 arg) (C1Sym1 arg) =>
C1Sym0KindInference
type instance Apply C1Sym0 l = C1Sym1 l
type (:&&@#@$$$) (t :: T0) (t :: T1) = (:&&) t t
instance SuppressUnusedWarnings (:&&@#@$$) where
suppressUnusedWarnings
= snd ((GHC.Tuple.(,) (::&&@#@$$###)) GHC.Tuple.())
data (:&&@#@$$) (l :: T0) (l :: TyFun T1 T1)
= forall arg. SameKind (Apply ((:&&@#@$$) l) arg) ((:&&@#@$$$) l arg) =>
(::&&@#@$$###)
type instance Apply ((:&&@#@$$) l) l = (:&&) l l
instance SuppressUnusedWarnings (:&&@#@$) where
suppressUnusedWarnings
= snd ((GHC.Tuple.(,) (::&&@#@$###)) GHC.Tuple.())
data (:&&@#@$) (l :: TyFun T0 (TyFun T1 T1 -> GHC.Types.Type))
= forall arg. SameKind (Apply (:&&@#@$) arg) ((:&&@#@$$) arg) =>
(::&&@#@$###)
type instance Apply (:&&@#@$) l = (:&&@#@$$) l
data instance Sing (z :: T1)
where
SN1 :: Sing N1
SC1 :: forall (n :: T0) (n :: T1).
(Sing (n :: T0)) -> (Sing (n :: T1)) -> Sing (C1 n n)
(:%&&) :: forall (n :: T0) (n :: T1).
(Sing (n :: T0)) -> (Sing (n :: T1)) -> Sing ((:&&) n n)
type ST1 = (Sing :: T1 -> GHC.Types.Type)
instance SingKind T1 where
type Demote T1 = T1
fromSing SN1 = N1
fromSing (SC1 b b) = (C1 (fromSing b)) (fromSing b)
fromSing ((:%&&) b b) = ((:&&) (fromSing b)) (fromSing b)
toSing N1 = SomeSing SN1
toSing (C1 (b :: Demote T0) (b :: Demote T1))
= case
(GHC.Tuple.(,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T1)
of {
GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing ((SC1 c) c) }
toSing ((:&&) (b :: Demote T0) (b :: Demote T1))
= case
(GHC.Tuple.(,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T1)
of {
GHC.Tuple.(,) (SomeSing c) (SomeSing c)
-> SomeSing (((:%&&) c) c) }
infixr 5 `SC1`
infixr 5 :%&&
instance SingI N1 where
sing = SN1
instance (SingI n, SingI n) => SingI (C1 (n :: T0) (n :: T1)) where
sing = (SC1 sing) sing
instance (SingI n, SingI n) =>
SingI ((:&&) (n :: T0) (n :: T1)) where
sing = ((:%&&) sing) sing
Singletons/T159.hs:(0,0)-(0,0): Splicing declarations
singletons
[d| infixr 5 :||
infixr 5 `C2`
data T2 = N2 | C2 T0 T2 | T0 :|| T2 |]
======>
data T2 = N2 | C2 T0 T2 | T0 :|| T2
infixr 5 `C2`
infixr 5 :||
type N2Sym0 = N2
type C2Sym2 (t :: T0) (t :: T2) = C2 t t
instance SuppressUnusedWarnings C2Sym1 where
suppressUnusedWarnings
= snd ((GHC.Tuple.(,) C2Sym1KindInference) GHC.Tuple.())
data C2Sym1 (l :: T0) (l :: TyFun T2 T2)
= forall arg. SameKind (Apply (C2Sym1 l) arg) (C2Sym2 l arg) =>
C2Sym1KindInference
type instance Apply (C2Sym1 l) l = C2 l l
instance SuppressUnusedWarnings C2Sym0 where
suppressUnusedWarnings
= snd ((GHC.Tuple.(,) C2Sym0KindInference) GHC.Tuple.())
data C2Sym0 (l :: TyFun T0 (TyFun T2 T2 -> GHC.Types.Type))
= forall arg. SameKind (Apply C2Sym0 arg) (C2Sym1 arg) =>
C2Sym0KindInference
type instance Apply C2Sym0 l = C2Sym1 l
type (:||@#@$$$) (t :: T0) (t :: T2) = (:||) t t
instance SuppressUnusedWarnings (:||@#@$$) where
suppressUnusedWarnings
= snd ((GHC.Tuple.(,) (::||@#@$$###)) GHC.Tuple.())
data (:||@#@$$) (l :: T0) (l :: TyFun T2 T2)
= forall arg. SameKind (Apply ((:||@#@$$) l) arg) ((:||@#@$$$) l arg) =>
(::||@#@$$###)
type instance Apply ((:||@#@$$) l) l = (:||) l l
instance SuppressUnusedWarnings (:||@#@$) where
suppressUnusedWarnings
= snd ((GHC.Tuple.(,) (::||@#@$###)) GHC.Tuple.())
data (:||@#@$) (l :: TyFun T0 (TyFun T2 T2 -> GHC.Types.Type))
= forall arg. SameKind (Apply (:||@#@$) arg) ((:||@#@$$) arg) =>
(::||@#@$###)
type instance Apply (:||@#@$) l = (:||@#@$$) l
infixr 5 :%||
infixr 5 `SC2`
data instance Sing (z :: T2)
where
SN2 :: Sing N2
SC2 :: forall (n :: T0) (n :: T2).
(Sing (n :: T0)) -> (Sing (n :: T2)) -> Sing (C2 n n)
(:%||) :: forall (n :: T0) (n :: T2).
(Sing (n :: T0)) -> (Sing (n :: T2)) -> Sing ((:||) n n)
type ST2 = (Sing :: T2 -> GHC.Types.Type)
instance SingKind T2 where
type Demote T2 = T2
fromSing SN2 = N2
fromSing (SC2 b b) = (C2 (fromSing b)) (fromSing b)
fromSing ((:%||) b b) = ((:||) (fromSing b)) (fromSing b)
toSing N2 = SomeSing SN2
toSing (C2 (b :: Demote T0) (b :: Demote T2))
= case
(GHC.Tuple.(,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T2)
of {
GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing ((SC2 c) c) }
toSing ((:||) (b :: Demote T0) (b :: Demote T2))
= case
(GHC.Tuple.(,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T2)
of {
GHC.Tuple.(,) (SomeSing c) (SomeSing c)
-> SomeSing (((:%||) c) c) }
instance SingI N2 where
sing = SN2
instance (SingI n, SingI n) => SingI (C2 (n :: T0) (n :: T2)) where
sing = (SC2 sing) sing
instance (SingI n, SingI n) =>
SingI ((:||) (n :: T0) (n :: T2)) where
sing = ((:%||) sing) sing