Singletons/EnumDeriving.hs:(0,0)-(0,0): Splicing declarations
    singletons
      [d| data Foo
            = Bar | Baz | Bum
            deriving (Enum)
          data Quux = Q1 | Q2 |]
  ======>
    data Foo
      = Bar | Baz | Bum
      deriving (Enum)
    data Quux = Q1 | Q2
    type BarSym0 = Bar
    type BazSym0 = Baz
    type BumSym0 = Bum
    type Q1Sym0 = Q1
    type Q2Sym0 = Q2
    type family Case_0123456789 n t where
      Case_0123456789 n True = BumSym0
      Case_0123456789 n False = Apply ErrorSym0 "toEnum: bad argument"
    type family Case_0123456789 n t where
      Case_0123456789 n True = BazSym0
      Case_0123456789 n False = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 2))
    type family Case_0123456789 n t where
      Case_0123456789 n True = BarSym0
      Case_0123456789 n False = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1))
    type family ToEnum_0123456789 (a :: GHC.TypeLits.Nat) :: Foo where
      ToEnum_0123456789 n = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0))
    type ToEnum_0123456789Sym1 (t :: GHC.TypeLits.Nat) =
        ToEnum_0123456789 t
    instance SuppressUnusedWarnings ToEnum_0123456789Sym0 where
      suppressUnusedWarnings _
        = snd
            (GHC.Tuple.(,) ToEnum_0123456789Sym0KindInference GHC.Tuple.())
    data ToEnum_0123456789Sym0 (l :: TyFun GHC.TypeLits.Nat Foo)
      = forall arg. KindOf (Apply ToEnum_0123456789Sym0 arg) ~ KindOf (ToEnum_0123456789Sym1 arg) =>
        ToEnum_0123456789Sym0KindInference
    type instance Apply ToEnum_0123456789Sym0 l = ToEnum_0123456789Sym1 l
    type family FromEnum_0123456789 (a :: Foo) :: GHC.TypeLits.Nat where
      FromEnum_0123456789 Bar = FromInteger 0
      FromEnum_0123456789 Baz = FromInteger 1
      FromEnum_0123456789 Bum = FromInteger 2
    type FromEnum_0123456789Sym1 (t :: Foo) = FromEnum_0123456789 t
    instance SuppressUnusedWarnings FromEnum_0123456789Sym0 where
      suppressUnusedWarnings _
        = snd
            (GHC.Tuple.(,) FromEnum_0123456789Sym0KindInference GHC.Tuple.())
    data FromEnum_0123456789Sym0 (l :: TyFun Foo GHC.TypeLits.Nat)
      = forall arg. KindOf (Apply FromEnum_0123456789Sym0 arg) ~ KindOf (FromEnum_0123456789Sym1 arg) =>
        FromEnum_0123456789Sym0KindInference
    type instance Apply FromEnum_0123456789Sym0 l = FromEnum_0123456789Sym1 l
    instance PEnum (KProxy :: KProxy Foo) where
      type ToEnum (a :: GHC.TypeLits.Nat) = Apply ToEnum_0123456789Sym0 a
      type FromEnum (a :: Foo) = Apply FromEnum_0123456789Sym0 a
    data instance Sing (z :: Foo)
      = z ~ Bar => SBar | z ~ Baz => SBaz | z ~ Bum => SBum
    type SFoo = (Sing :: Foo -> *)
    instance SingKind (KProxy :: KProxy Foo) where
      type DemoteRep (KProxy :: KProxy Foo) = Foo
      fromSing SBar = Bar
      fromSing SBaz = Baz
      fromSing SBum = Bum
      toSing Bar = SomeSing SBar
      toSing Baz = SomeSing SBaz
      toSing Bum = SomeSing SBum
    data instance Sing (z :: Quux) = z ~ Q1 => SQ1 | z ~ Q2 => SQ2
    type SQuux = (Sing :: Quux -> *)
    instance SingKind (KProxy :: KProxy Quux) where
      type DemoteRep (KProxy :: KProxy Quux) = Quux
      fromSing SQ1 = Q1
      fromSing SQ2 = Q2
      toSing Q1 = SomeSing SQ1
      toSing Q2 = SomeSing SQ2
    instance SEnum (KProxy :: KProxy Foo) where
      sToEnum ::
        forall (t0 :: GHC.TypeLits.Nat).
        Sing t0
        -> Sing (Apply (ToEnumSym0 :: TyFun GHC.TypeLits.Nat Foo
                                      -> *) t0 :: Foo)
      sFromEnum ::
        forall (t0 :: Foo).
        Sing t0
        -> Sing (Apply (FromEnumSym0 :: TyFun Foo GHC.TypeLits.Nat
                                        -> *) t0 :: GHC.TypeLits.Nat)
      sToEnum sN
        = let
            lambda ::
              forall n. t0 ~ n => Sing n -> Sing (Apply ToEnumSym0 n :: Foo)
            lambda n
              = case
                    applySing
                      (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n)
                      (sFromInteger (sing :: Sing 0))
                of {
                  STrue
                    -> let
                         lambda ::
                           TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) =>
                           Sing (Case_0123456789 n TrueSym0)
                         lambda = SBar
                       in lambda
                  SFalse
                    -> let
                         lambda ::
                           FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) =>
                           Sing (Case_0123456789 n FalseSym0)
                         lambda
                           = case
                                 applySing
                                   (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n)
                                   (sFromInteger (sing :: Sing 1))
                             of {
                               STrue
                                 -> let
                                      lambda ::
                                        TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) =>
                                        Sing (Case_0123456789 n TrueSym0)
                                      lambda = SBaz
                                    in lambda
                               SFalse
                                 -> let
                                      lambda ::
                                        FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) =>
                                        Sing (Case_0123456789 n FalseSym0)
                                      lambda
                                        = case
                                              applySing
                                                (applySing
                                                   (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n)
                                                (sFromInteger (sing :: Sing 2))
                                          of {
                                            STrue
                                              -> let
                                                   lambda ::
                                                     TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 2) =>
                                                     Sing (Case_0123456789 n TrueSym0)
                                                   lambda = SBum
                                                 in lambda
                                            SFalse
                                              -> let
                                                   lambda ::
                                                     FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 2) =>
                                                     Sing (Case_0123456789 n FalseSym0)
                                                   lambda
                                                     = sError (sing :: Sing "toEnum: bad argument")
                                                 in lambda } ::
                                            Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 2)))
                                    in lambda } ::
                               Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1)))
                       in lambda } ::
                  Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0)))
          in lambda sN
      sFromEnum SBar
        = let
            lambda ::
              t0 ~ BarSym0 =>
              Sing (Apply FromEnumSym0 BarSym0 :: GHC.TypeLits.Nat)
            lambda = sFromInteger (sing :: Sing 0)
          in lambda
      sFromEnum SBaz
        = let
            lambda ::
              t0 ~ BazSym0 =>
              Sing (Apply FromEnumSym0 BazSym0 :: GHC.TypeLits.Nat)
            lambda = sFromInteger (sing :: Sing 1)
          in lambda
      sFromEnum SBum
        = let
            lambda ::
              t0 ~ BumSym0 =>
              Sing (Apply FromEnumSym0 BumSym0 :: GHC.TypeLits.Nat)
            lambda = sFromInteger (sing :: Sing 2)
          in lambda
    instance SingI Bar where
      sing = SBar
    instance SingI Baz where
      sing = SBaz
    instance SingI Bum where
      sing = SBum
    instance SingI Q1 where
      sing = SQ1
    instance SingI Q2 where
      sing = SQ2
Singletons/EnumDeriving.hs:0:0:: Splicing declarations
    singEnumInstance ''Quux
  ======>
    type family Case_0123456789 n t where
      Case_0123456789 n True = Q2Sym0
      Case_0123456789 n False = Apply ErrorSym0 "toEnum: bad argument"
    type family Case_0123456789 n t where
      Case_0123456789 n True = Q1Sym0
      Case_0123456789 n False = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1))
    type family ToEnum_0123456789 (a :: GHC.TypeLits.Nat) :: Quux where
      ToEnum_0123456789 n = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0))
    type ToEnum_0123456789Sym1 (t :: GHC.TypeLits.Nat) =
        ToEnum_0123456789 t
    instance SuppressUnusedWarnings ToEnum_0123456789Sym0 where
      suppressUnusedWarnings _
        = snd
            (GHC.Tuple.(,) ToEnum_0123456789Sym0KindInference GHC.Tuple.())
    data ToEnum_0123456789Sym0 (l :: TyFun GHC.TypeLits.Nat Quux)
      = forall arg. KindOf (Apply ToEnum_0123456789Sym0 arg) ~ KindOf (ToEnum_0123456789Sym1 arg) =>
        ToEnum_0123456789Sym0KindInference
    type instance Apply ToEnum_0123456789Sym0 l = ToEnum_0123456789Sym1 l
    type family FromEnum_0123456789 (a :: Quux) :: GHC.TypeLits.Nat where
      FromEnum_0123456789 Q1 = FromInteger 0
      FromEnum_0123456789 Q2 = FromInteger 1
    type FromEnum_0123456789Sym1 (t :: Quux) = FromEnum_0123456789 t
    instance SuppressUnusedWarnings FromEnum_0123456789Sym0 where
      suppressUnusedWarnings _
        = snd
            (GHC.Tuple.(,) FromEnum_0123456789Sym0KindInference GHC.Tuple.())
    data FromEnum_0123456789Sym0 (l :: TyFun Quux GHC.TypeLits.Nat)
      = forall arg. KindOf (Apply FromEnum_0123456789Sym0 arg) ~ KindOf (FromEnum_0123456789Sym1 arg) =>
        FromEnum_0123456789Sym0KindInference
    type instance Apply FromEnum_0123456789Sym0 l = FromEnum_0123456789Sym1 l
    instance PEnum (KProxy :: KProxy Quux) where
      type ToEnum (a :: GHC.TypeLits.Nat) = Apply ToEnum_0123456789Sym0 a
      type FromEnum (a :: Quux) = Apply FromEnum_0123456789Sym0 a
    instance SEnum (KProxy :: KProxy Quux) where
      sToEnum ::
        forall (t0 :: GHC.TypeLits.Nat).
        Sing t0
        -> Sing (Apply (ToEnumSym0 :: TyFun GHC.TypeLits.Nat Quux
                                      -> *) t0 :: Quux)
      sFromEnum ::
        forall (t0 :: Quux).
        Sing t0
        -> Sing (Apply (FromEnumSym0 :: TyFun Quux GHC.TypeLits.Nat
                                        -> *) t0 :: GHC.TypeLits.Nat)
      sToEnum sN
        = let
            lambda ::
              forall n. t0 ~ n => Sing n -> Sing (Apply ToEnumSym0 n :: Quux)
            lambda n
              = case
                    applySing
                      (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n)
                      (sFromInteger (sing :: Sing 0))
                of {
                  STrue
                    -> let
                         lambda ::
                           TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) =>
                           Sing (Case_0123456789 n TrueSym0)
                         lambda = SQ1
                       in lambda
                  SFalse
                    -> let
                         lambda ::
                           FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) =>
                           Sing (Case_0123456789 n FalseSym0)
                         lambda
                           = case
                                 applySing
                                   (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n)
                                   (sFromInteger (sing :: Sing 1))
                             of {
                               STrue
                                 -> let
                                      lambda ::
                                        TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) =>
                                        Sing (Case_0123456789 n TrueSym0)
                                      lambda = SQ2
                                    in lambda
                               SFalse
                                 -> let
                                      lambda ::
                                        FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) =>
                                        Sing (Case_0123456789 n FalseSym0)
                                      lambda = sError (sing :: Sing "toEnum: bad argument")
                                    in lambda } ::
                               Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1)))
                       in lambda } ::
                  Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0)))
          in lambda sN
      sFromEnum SQ1
        = let
            lambda ::
              t0 ~ Q1Sym0 => Sing (Apply FromEnumSym0 Q1Sym0 :: GHC.TypeLits.Nat)
            lambda = sFromInteger (sing :: Sing 0)
          in lambda
      sFromEnum SQ2
        = let
            lambda ::
              t0 ~ Q2Sym0 => Sing (Apply FromEnumSym0 Q2Sym0 :: GHC.TypeLits.Nat)
            lambda = sFromInteger (sing :: Sing 1)
          in lambda