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