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