singletons-2.3: tests/compile-and-dump/Singletons/T159.ghc82.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)
= z ~ A => SA |
z ~ B => SB |
z ~ C => SC |
z ~ D => SD |
z ~ E => SE |
z ~ F => SF
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)
= z ~ N1 => SN1 |
forall (n :: T0) (n :: T1). z ~ C1 n n =>
SC1 (Sing (n :: T0)) (Sing (n :: T1)) |
forall (n :: T0) (n :: T1). z ~ (:&&) n n =>
(:%&&) (Sing (n :: T0)) (Sing (n :: T1))
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 b)
= case
(GHC.Tuple.(,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T1)
of {
GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing ((SC1 c) c) }
toSing ((:&&) b b)
= 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)
= z ~ N2 => SN2 |
forall (n :: T0) (n :: T2). z ~ C2 n n =>
SC2 (Sing (n :: T0)) (Sing (n :: T2)) |
forall (n :: T0) (n :: T2). z ~ (:||) n n =>
(:%||) (Sing (n :: T0)) (Sing (n :: T2))
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 b)
= case
(GHC.Tuple.(,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T2)
of {
GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing ((SC2 c) c) }
toSing ((:||) b b)
= 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