Promote/Classes.hs:0:0: Splicing declarations
    promote
      [d| const :: a -> b -> a
          const x _ = x
          fooCompare :: Foo -> Foo -> Ordering
          fooCompare A A = EQ
          fooCompare A _ = LT
          fooCompare _ _ = GT
          
          class MyOrd a where
            mycompare :: a -> a -> Ordering
            (<=>) :: a -> a -> Ordering
            (<=>) = mycompare
          data Foo = A | B
          
          instance MyOrd Foo where
            mycompare = fooCompare
          instance MyOrd () where
            mycompare _ = const EQ
          instance MyOrd Nat where
            Zero `mycompare` Zero = EQ
            Zero `mycompare` (Succ _) = LT
            (Succ _) `mycompare` Zero = GT
            (Succ n) `mycompare` (Succ m) = m `mycompare` n |]
  ======>
    Promote/Classes.hs:(0,0)-(0,0)
    const :: forall a b. a -> b -> a
    const x _ = x
    class MyOrd a where
      mycompare :: a -> a -> Ordering
      (<=>) :: a -> a -> Ordering
      (<=>) = mycompare
    instance MyOrd Nat where
      mycompare Zero Zero = EQ
      mycompare Zero (Succ _) = LT
      mycompare (Succ _) Zero = GT
      mycompare (Succ n) (Succ m) = (m `mycompare` n)
    instance MyOrd () where
      mycompare _ = const EQ
    data Foo = A | B
    fooCompare :: Foo -> Foo -> Ordering
    fooCompare A A = EQ
    fooCompare A _ = LT
    fooCompare _ _ = GT
    instance MyOrd Foo where
      mycompare = fooCompare
    type FooCompareSym2 (t :: Foo) (t :: Foo) = FooCompare t t
    instance SuppressUnusedWarnings FooCompareSym1 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) FooCompareSym1KindInference GHC.Tuple.())
    data FooCompareSym1 (l :: Foo) (l :: TyFun Foo Ordering)
      = forall arg. (GHC.Types.~) (KindOf (Apply (FooCompareSym1 l) arg)) (KindOf (FooCompareSym2 l arg)) =>
        FooCompareSym1KindInference
    type instance Apply (FooCompareSym1 l) l = FooCompareSym2 l l
    instance SuppressUnusedWarnings FooCompareSym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) FooCompareSym0KindInference GHC.Tuple.())
    data FooCompareSym0 (l :: TyFun Foo (TyFun Foo Ordering -> *))
      = forall arg. (GHC.Types.~) (KindOf (Apply FooCompareSym0 arg)) (KindOf (FooCompareSym1 arg)) =>
        FooCompareSym0KindInference
    type instance Apply FooCompareSym0 l = FooCompareSym1 l
    type ConstSym2 (t :: a) (t :: b) = Const t t
    instance SuppressUnusedWarnings ConstSym1 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) ConstSym1KindInference GHC.Tuple.())
    data ConstSym1 (l :: a) (l :: TyFun b a)
      = forall arg. (GHC.Types.~) (KindOf (Apply (ConstSym1 l) arg)) (KindOf (ConstSym2 l arg)) =>
        ConstSym1KindInference
    type instance Apply (ConstSym1 l) l = ConstSym2 l l
    instance SuppressUnusedWarnings ConstSym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) ConstSym0KindInference GHC.Tuple.())
    data ConstSym0 (l :: TyFun a (TyFun b a -> *))
      = forall arg. (GHC.Types.~) (KindOf (Apply ConstSym0 arg)) (KindOf (ConstSym1 arg)) =>
        ConstSym0KindInference
    type instance Apply ConstSym0 l = ConstSym1 l
    type family FooCompare (a :: Foo) (a :: Foo) :: Ordering where
      FooCompare A A = EQSym0
      FooCompare A z = LTSym0
      FooCompare z z = GTSym0
    type family Const (a :: a) (a :: b) :: a where
      Const x z = x
    type MycompareSym2 (t :: a) (t :: a) = Mycompare t t
    instance SuppressUnusedWarnings MycompareSym1 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) MycompareSym1KindInference GHC.Tuple.())
    data MycompareSym1 (l :: a) (l :: TyFun a Ordering)
      = forall arg. (GHC.Types.~) (KindOf (Apply (MycompareSym1 l) arg)) (KindOf (MycompareSym2 l arg)) =>
        MycompareSym1KindInference
    type instance Apply (MycompareSym1 l) l = MycompareSym2 l l
    instance SuppressUnusedWarnings MycompareSym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) MycompareSym0KindInference GHC.Tuple.())
    data MycompareSym0 (l :: TyFun a (TyFun a Ordering -> *))
      = forall arg. (GHC.Types.~) (KindOf (Apply MycompareSym0 arg)) (KindOf (MycompareSym1 arg)) =>
        MycompareSym0KindInference
    type instance Apply MycompareSym0 l = MycompareSym1 l
    type (:<=>$$$) (t :: a) (t :: a) = (:<=>) t t
    instance SuppressUnusedWarnings (:<=>$$) where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) (:<=>$$###) GHC.Tuple.())
    data (:<=>$$) (l :: a) (l :: TyFun a Ordering)
      = forall arg. (GHC.Types.~) (KindOf (Apply ((:<=>$$) l) arg)) (KindOf ((:<=>$$$) l arg)) =>
        (:<=>$$###)
    type instance Apply ((:<=>$$) l) l = (:<=>$$$) l l
    instance SuppressUnusedWarnings (:<=>$) where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) (:<=>$###) GHC.Tuple.())
    data (:<=>$) (l :: TyFun a (TyFun a Ordering -> *))
      = forall arg. (GHC.Types.~) (KindOf (Apply (:<=>$) arg)) (KindOf ((:<=>$$) arg)) =>
        (:<=>$###)
    type instance Apply (:<=>$) l = (:<=>$$) l
    class (GHC.Types.~) kproxy KProxy => PMyOrd (kproxy :: KProxy a) where
      type family Mycompare (arg :: a) (arg :: a) :: Ordering
      type family (:<=>) (arg :: a) (arg :: a) :: Ordering
      type instance (:<=>) (a_0123456789 :: a) (a_0123456789 :: a) = (Apply (Apply MycompareSym0 a_0123456789) a_0123456789 :: Ordering)
    instance PMyOrd (KProxy :: KProxy Nat) where
      type Mycompare (Zero :: Nat) (Zero :: Nat) = (EQSym0 :: Ordering)
      type Mycompare (Zero :: Nat) (Succ z :: Nat) = (LTSym0 :: Ordering)
      type Mycompare (Succ z :: Nat) (Zero :: Nat) = (GTSym0 :: Ordering)
      type Mycompare (Succ n :: Nat) (Succ m :: Nat) = (Apply (Apply MycompareSym0 m) n :: Ordering)
    instance PMyOrd (KProxy :: KProxy GHC.Tuple.()) where
      type Mycompare (z :: GHC.Tuple.()) (a_0123456789 :: GHC.Tuple.()) = (Apply (Apply ConstSym0 EQSym0) a_0123456789 :: Ordering)
    instance PMyOrd (KProxy :: KProxy Foo) where
      type Mycompare (a_0123456789 :: Foo) (a_0123456789 :: Foo) = (Apply (Apply FooCompareSym0 a_0123456789) a_0123456789 :: Ordering)
    type ASym0 = A
    type BSym0 = B
Promote/Classes.hs:0:0: Splicing declarations
    promote
      [d| data Nat' = Zero' | Succ' Nat'
          
          instance MyOrd Nat' where
            Zero' `mycompare` Zero' = EQ
            Zero' `mycompare` (Succ' _) = LT
            (Succ' _) `mycompare` Zero' = GT
            (Succ' n) `mycompare` (Succ' m) = m `mycompare` n |]
  ======>
    Promote/Classes.hs:(0,0)-(0,0)
    data Nat' = Zero' | Succ' Nat'
    instance MyOrd Nat' where
      mycompare Zero' Zero' = EQ
      mycompare Zero' (Succ' _) = LT
      mycompare (Succ' _) Zero' = GT
      mycompare (Succ' n) (Succ' m) = (m `mycompare` n)
    instance PMyOrd (KProxy :: KProxy Nat') where
      type Mycompare (Zero' :: Nat') (Zero' :: Nat') = (EQSym0 :: Ordering)
      type Mycompare (Zero' :: Nat') (Succ' z :: Nat') = (LTSym0 :: Ordering)
      type Mycompare (Succ' z :: Nat') (Zero' :: Nat') = (GTSym0 :: Ordering)
      type Mycompare (Succ' n :: Nat') (Succ' m :: Nat') = (Apply (Apply MycompareSym0 m) n :: Ordering)
    type Zero'Sym0 = Zero'
    type Succ'Sym1 (t :: Nat') = Succ' t
    instance SuppressUnusedWarnings Succ'Sym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Succ'Sym0KindInference GHC.Tuple.())
    data Succ'Sym0 (l :: TyFun Nat' Nat')
      = forall arg. (GHC.Types.~) (KindOf (Apply Succ'Sym0 arg)) (KindOf (Succ'Sym1 arg)) =>
        Succ'Sym0KindInference
    type instance Apply Succ'Sym0 l = Succ'Sym1 l