Singletons/T176.hs:(0,0)-(0,0): Splicing declarations
    singletons
      [d| quux1 :: Foo1 a => a -> a
          quux1 x = x `bar1` \ _ -> baz1
          quux2 :: Foo2 a => a -> a
          quux2 x = x `bar2` baz2
          
          class Foo1 a where
            bar1 :: a -> (a -> b) -> b
            baz1 :: a
          class Foo2 a where
            bar2 :: a -> b -> b
            baz2 :: a |]
  ======>
    class Foo1 a where
      bar1 :: a -> (a -> b) -> b
      baz1 :: a
    quux1 :: Foo1 a => a -> a
    quux1 x = (x `bar1` (\ _ -> baz1))
    class Foo2 a where
      bar2 :: a -> b -> b
      baz2 :: a
    quux2 :: Foo2 a => a -> a
    quux2 x = (x `bar2` baz2)
    type family Case_0123456789876543210 x arg_0123456789876543210 t where
      Case_0123456789876543210 x arg_0123456789876543210 _z_0123456789876543210 = Baz1Sym0
    type family Lambda_0123456789876543210 x t where
      Lambda_0123456789876543210 x arg_0123456789876543210 = Case_0123456789876543210 x arg_0123456789876543210 arg_0123456789876543210
    type Lambda_0123456789876543210Sym2 t t =
        Lambda_0123456789876543210 t t
    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym1 where
      suppressUnusedWarnings _
        = snd
            ((GHC.Tuple.(,) Lambda_0123456789876543210Sym1KindInference)
               GHC.Tuple.())
    data Lambda_0123456789876543210Sym1 l l
      = forall arg. SameKind (Apply (Lambda_0123456789876543210Sym1 l) arg) (Lambda_0123456789876543210Sym2 l arg) =>
        Lambda_0123456789876543210Sym1KindInference
    type instance Apply (Lambda_0123456789876543210Sym1 l) l = Lambda_0123456789876543210 l l
    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
      suppressUnusedWarnings _
        = snd
            ((GHC.Tuple.(,) Lambda_0123456789876543210Sym0KindInference)
               GHC.Tuple.())
    data Lambda_0123456789876543210Sym0 l
      = forall arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
        Lambda_0123456789876543210Sym0KindInference
    type instance Apply Lambda_0123456789876543210Sym0 l = Lambda_0123456789876543210Sym1 l
    type Quux2Sym1 (t :: a0123456789876543210) = Quux2 t
    instance SuppressUnusedWarnings Quux2Sym0 where
      suppressUnusedWarnings _
        = snd ((GHC.Tuple.(,) Quux2Sym0KindInference) GHC.Tuple.())
    data Quux2Sym0 (l :: TyFun a0123456789876543210 a0123456789876543210)
      = forall arg. SameKind (Apply Quux2Sym0 arg) (Quux2Sym1 arg) =>
        Quux2Sym0KindInference
    type instance Apply Quux2Sym0 l = Quux2 l
    type Quux1Sym1 (t :: a0123456789876543210) = Quux1 t
    instance SuppressUnusedWarnings Quux1Sym0 where
      suppressUnusedWarnings _
        = snd ((GHC.Tuple.(,) Quux1Sym0KindInference) GHC.Tuple.())
    data Quux1Sym0 (l :: TyFun a0123456789876543210 a0123456789876543210)
      = forall arg. SameKind (Apply Quux1Sym0 arg) (Quux1Sym1 arg) =>
        Quux1Sym0KindInference
    type instance Apply Quux1Sym0 l = Quux1 l
    type family Quux2 (a :: a) :: a where
      Quux2 x = Apply (Apply Bar2Sym0 x) Baz2Sym0
    type family Quux1 (a :: a) :: a where
      Quux1 x = Apply (Apply Bar1Sym0 x) (Apply Lambda_0123456789876543210Sym0 x)
    type Bar1Sym2 (t :: a0123456789876543210) (t :: TyFun a0123456789876543210 b0123456789876543210
                                                    -> Type) =
        Bar1 t t
    instance SuppressUnusedWarnings Bar1Sym1 where
      suppressUnusedWarnings _
        = snd ((GHC.Tuple.(,) Bar1Sym1KindInference) GHC.Tuple.())
    data Bar1Sym1 (l :: a0123456789876543210) (l :: TyFun (TyFun a0123456789876543210 b0123456789876543210
                                                           -> Type) b0123456789876543210)
      = forall arg. SameKind (Apply (Bar1Sym1 l) arg) (Bar1Sym2 l arg) =>
        Bar1Sym1KindInference
    type instance Apply (Bar1Sym1 l) l = Bar1 l l
    instance SuppressUnusedWarnings Bar1Sym0 where
      suppressUnusedWarnings _
        = snd ((GHC.Tuple.(,) Bar1Sym0KindInference) GHC.Tuple.())
    data Bar1Sym0 (l :: TyFun a0123456789876543210 (TyFun (TyFun a0123456789876543210 b0123456789876543210
                                                           -> Type) b0123456789876543210
                                                    -> Type))
      = forall arg. SameKind (Apply Bar1Sym0 arg) (Bar1Sym1 arg) =>
        Bar1Sym0KindInference
    type instance Apply Bar1Sym0 l = Bar1Sym1 l
    type Baz1Sym0 = Baz1
    class PFoo1 (a :: Type) where
      type Bar1 (arg :: a) (arg :: TyFun a b -> Type) :: b
      type Baz1 :: a
    type Bar2Sym2 (t :: a0123456789876543210) (t :: b0123456789876543210) =
        Bar2 t t
    instance SuppressUnusedWarnings Bar2Sym1 where
      suppressUnusedWarnings _
        = snd ((GHC.Tuple.(,) Bar2Sym1KindInference) GHC.Tuple.())
    data Bar2Sym1 (l :: a0123456789876543210) (l :: TyFun b0123456789876543210 b0123456789876543210)
      = forall arg. SameKind (Apply (Bar2Sym1 l) arg) (Bar2Sym2 l arg) =>
        Bar2Sym1KindInference
    type instance Apply (Bar2Sym1 l) l = Bar2 l l
    instance SuppressUnusedWarnings Bar2Sym0 where
      suppressUnusedWarnings _
        = snd ((GHC.Tuple.(,) Bar2Sym0KindInference) GHC.Tuple.())
    data Bar2Sym0 (l :: TyFun a0123456789876543210 (TyFun b0123456789876543210 b0123456789876543210
                                                    -> Type))
      = forall arg. SameKind (Apply Bar2Sym0 arg) (Bar2Sym1 arg) =>
        Bar2Sym0KindInference
    type instance Apply Bar2Sym0 l = Bar2Sym1 l
    type Baz2Sym0 = Baz2
    class PFoo2 (a :: Type) where
      type Bar2 (arg :: a) (arg :: b) :: b
      type Baz2 :: a
    sQuux2 ::
      forall (t :: a). SFoo2 a => Sing t -> Sing (Apply Quux2Sym0 t :: a)
    sQuux1 ::
      forall (t :: a). SFoo1 a => Sing t -> Sing (Apply Quux1Sym0 t :: a)
    sQuux2 (sX :: Sing x)
      = (applySing ((applySing ((singFun2 @Bar2Sym0) sBar2)) sX)) sBaz2
    sQuux1 (sX :: Sing x)
      = (applySing ((applySing ((singFun2 @Bar1Sym0) sBar1)) sX))
          ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x))
             (\ sArg_0123456789876543210
                -> case sArg_0123456789876543210 of {
                     _ :: Sing arg_0123456789876543210
                       -> case sArg_0123456789876543210 of { _ -> sBaz1 } ::
                            Sing (Case_0123456789876543210 x arg_0123456789876543210 arg_0123456789876543210) }))
    class SFoo1 a where
      sBar1 ::
        forall (t :: a) (t :: TyFun a b -> Type).
        Sing t -> Sing t -> Sing (Apply (Apply Bar1Sym0 t) t :: b)
      sBaz1 :: Sing (Baz1Sym0 :: a)
    class SFoo2 a where
      sBar2 ::
        forall (t :: a) (t :: b).
        Sing t -> Sing t -> Sing (Apply (Apply Bar2Sym0 t) t :: b)
      sBaz2 :: Sing (Baz2Sym0 :: a)