diff --git a/CHANGES.md b/CHANGES.md
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,33 @@
 Changelog for singletons project
 ================================
 
+1.1
+---
+
+This is a maintenance release to support building (but *not* testing, due to
+GHC bug #10058) with 7.10. This release also targets th-desugar-1.5. Some
+types changed (using th-desugar's new `DsMonad` instead of `Quasi`), but
+clients generally won't need to make any changes, unless they, too, generalize
+over `Quasi`.
+
+1.0
+---
+
+This is a complete rewrite of the package.
+
+* A much wider array of surface syntax is now accepted for promotion
+and singletonization, including `let`, `case`, partially-applied functions,
+and anonymous functions, `where`, sections, among others.
+
+* Classes and instances can be promoted (but not singletonized).
+
+* Derivation of promoted instances for `Ord` and `Bounded`.
+
+This release can be seen as a "technology preview". More features are coming
+soon.
+
+This version drops GHC 7.6 support.
+
 0.10.0
 ------
 
diff --git a/singletons.cabal b/singletons.cabal
--- a/singletons.cabal
+++ b/singletons.cabal
@@ -1,5 +1,5 @@
 name:           singletons
-version:        1.0
+version:        1.1
                 -- Remember to bump version in the Makefile as well
 cabal-version:  >= 1.10
 synopsis:       A framework for generating singleton types
@@ -9,7 +9,7 @@
 maintainer:     Richard Eisenberg <eir@cis.upenn.edu>, Jan Stolarek <jan.stolarek@p.lodz.pl>
 bug-reports:    https://github.com/goldfirere/singletons/issues
 stability:      experimental
-tested-with:    GHC ==7.8.2
+tested-with:    GHC ==7.8.3
 extra-source-files: README.md, CHANGES.md,
                     tests/compile-and-dump/buildGoldenFiles.awk,
                     tests/compile-and-dump/GradingClient/*.hs,
@@ -42,7 +42,7 @@
 source-repository this
   type:     git
   location: https://github.com/goldfirere/singletons.git
-  tag:      v1.0
+  tag:      v1.1
 
 library
   hs-source-dirs:     src
@@ -50,7 +50,7 @@
                       mtl >= 2.1.1,
                       template-haskell,
                       containers >= 0.5,
-                      th-desugar >= 1.4
+                      th-desugar >= 1.5 && < 1.6
   default-language:   Haskell2010
   default-extensions: TemplateHaskell
         -- TemplateHaskell must be listed in cabal file to work with
diff --git a/src/Data/Promotion/Prelude.hs b/src/Data/Promotion/Prelude.hs
--- a/src/Data/Promotion/Prelude.hs
+++ b/src/Data/Promotion/Prelude.hs
@@ -102,7 +102,7 @@
   FlipSym0, FlipSym1, FlipSym2,
   AsTypeOfSym0, AsTypeOfSym1, AsTypeOfSym2, SeqSym0, SeqSym1, SeqSym2,
 
-  (:$), (:$$), (:$$$), NilSym0, ConsSym0, ConsSym1, ConsSym2,
+  (:$), (:$$), (:$$$), NilSym0,
   MapSym0, MapSym1, MapSym2, ReverseSym0, ReverseSym1,
   (:++$$), (:++$), HeadSym0, HeadSym1, LastSym0, LastSym1,
   TailSym0, TailSym1, InitSym0, InitSym1, NullSym0, NullSym1,
diff --git a/src/Data/Promotion/Prelude/List.hs b/src/Data/Promotion/Prelude/List.hs
--- a/src/Data/Promotion/Prelude/List.hs
+++ b/src/Data/Promotion/Prelude/List.hs
@@ -101,8 +101,8 @@
   GenericSplitAt, GenericIndex, GenericReplicate,
 
   -- * Defunctionalization symbols
+  NilSym0,
   (:$), (:$$), (:$$$),
-  NilSym0, ConsSym0, ConsSym1, ConsSym2,
 
   (:++$$), (:++$), HeadSym0, HeadSym1, LastSym0, LastSym1,
   TailSym0, TailSym1, InitSym0, InitSym1, NullSym0, NullSym1,
diff --git a/src/Data/Singletons/CustomStar.hs b/src/Data/Singletons/CustomStar.hs
--- a/src/Data/Singletons/CustomStar.hs
+++ b/src/Data/Singletons/CustomStar.hs
@@ -24,7 +24,6 @@
   ) where
 
 import Language.Haskell.TH
-import Language.Haskell.TH.Syntax ( Quasi(..) )
 import Data.Singletons.Util
 import Data.Singletons.Promote
 import Data.Singletons.Promote.Monad
@@ -36,7 +35,6 @@
 import Data.Maybe
 import Control.Applicative
 import Language.Haskell.TH.Desugar
-import Language.Haskell.TH.Desugar.Sweeten
 import Data.Singletons.Prelude.Eq
 import Data.Singletons.Prelude.Bool
 
@@ -66,7 +64,7 @@
 -- @Bool@, and @Maybe@, not just promoted data constructors.
 --
 -- Please note that this function is /very/ experimental. Use at your own risk.
-singletonStar :: Quasi q
+singletonStar :: DsMonad q
               => [Name]        -- ^ A list of Template Haskell @Name@s for types
               -> q [Dec]
 singletonStar names = do
@@ -76,13 +74,13 @@
                        [''Eq, ''Show, ''Read]
   fakeCtors <- zipWithM (mkCtor False) names kinds
   let dataDecl = DataDecl Data repName [] fakeCtors [''Show, ''Read , ''Eq, ''Ord]
-  promDecls      <- promoteM_ $ promoteDataDec dataDecl
-  singletonDecls <- singDecsM $ singDataD dataDecl
+  promDecls      <- promoteM_ [] $ promoteDataDec dataDecl
+  singletonDecls <- singDecsM [] $ singDataD dataDecl
   return $ decsToTH $ repDecl :
                       promDecls ++
                       singletonDecls
   where -- get the kinds of the arguments to the tycon with the given name
-        getKind :: Quasi q => Name -> q [DKind]
+        getKind :: DsMonad q => Name -> q [DKind]
         getKind name = do
           info <- reifyWithWarning name
           dinfo <- dsInfo info
@@ -99,7 +97,7 @@
 
         -- first parameter is whether this is a real ctor (with a fresh name)
         -- or a fake ctor (when the name is actually a Haskell type)
-        mkCtor :: Quasi q => Bool -> Name -> [DKind] -> q DCon
+        mkCtor :: DsMonad q => Bool -> Name -> [DKind] -> q DCon
         mkCtor real name args = do
           (types, vars) <- evalForPair $ mapM kindToType args
           dataName <- if real then mkDataName (nameBase name) else return name
@@ -107,7 +105,7 @@
                    DNormalC (map (\ty -> (NotStrict, ty)) types)
 
         -- demote a kind back to a type, accumulating any unbound parameters
-        kindToType :: Quasi q => DKind -> QWithAux [Name] q DType
+        kindToType :: DsMonad q => DKind -> QWithAux [Name] q DType
         kindToType (DForallK _ _) = fail "Explicit forall encountered in kind"
         kindToType (DVarK n) = do
           addElement n
diff --git a/src/Data/Singletons/Names.hs b/src/Data/Singletons/Names.hs
--- a/src/Data/Singletons/Names.hs
+++ b/src/Data/Singletons/Names.hs
@@ -121,6 +121,9 @@
     | name == undefinedName
     = anyTypeName
 
+    | name == nilName
+    = mkName $ "NilSym" ++ (show sat)
+
     | Just degree <- tupleNameDegree_maybe name
     = mkName $ "Tuple" ++ show degree ++ "Sym" ++ (show sat)
 
@@ -142,7 +145,7 @@
 classTvsName :: Name -> Name
 classTvsName = suffixName "TyVars" "^^^"
 
-mkTyName :: Quasi q => Name -> q Name
+mkTyName :: DsMonad q => Name -> q Name
 mkTyName tmName = do
   let nameStr  = nameBase tmName
       symbolic = not (isHsLetter (head nameStr))
@@ -163,7 +166,7 @@
 -- make a Name with an unknown kind into a DTyVarBndr.
 -- Uses a fresh kind variable for GHC 7.6.3 and PlainTV for 7.8+
 -- because 7.8+ has kind inference
-inferKindTV :: Quasi q => Name -> q DTyVarBndr
+inferKindTV :: DsMonad q => Name -> q DTyVarBndr
 inferKindTV n = do
 #if __GLASGOW_HASKELL__ < 707
   ki <- fmap DVarK $ qNewName "k"
@@ -172,7 +175,7 @@
   return $ DPlainTV n
 #endif
 
-inferMaybeKindTV :: Quasi q => Name -> Maybe DKind -> q DTyVarBndr
+inferMaybeKindTV :: DsMonad q => Name -> Maybe DKind -> q DTyVarBndr
 inferMaybeKindTV n Nothing =
 #if __GLASGOW_HASKELL__ < 707
   do k <- qNewName "k"
diff --git a/src/Data/Singletons/Prelude.hs b/src/Data/Singletons/Prelude.hs
--- a/src/Data/Singletons/Prelude.hs
+++ b/src/Data/Singletons/Prelude.hs
@@ -152,7 +152,7 @@
   FlipSym0, FlipSym1, FlipSym2,
   AsTypeOfSym0, AsTypeOfSym1, AsTypeOfSym2, SeqSym0, SeqSym1, SeqSym2,
 
-  (:$), (:$$), (:$$$), NilSym0, ConsSym0, ConsSym1, ConsSym2,
+  (:$), (:$$), (:$$$), NilSym0,
   MapSym0, MapSym1, MapSym2, ReverseSym0, ReverseSym1,
   (:++$$), (:++$), HeadSym0, HeadSym1, LastSym0, LastSym1,
   TailSym0, TailSym1, InitSym0, InitSym1, NullSym0, NullSym1,
diff --git a/src/Data/Singletons/Prelude/List.hs b/src/Data/Singletons/Prelude/List.hs
--- a/src/Data/Singletons/Prelude/List.hs
+++ b/src/Data/Singletons/Prelude/List.hs
@@ -101,8 +101,8 @@
   MaximumBy, sMaximumBy, MinimumBy, sMinimumBy,
 
   -- * Defunctionalization symbols
+  NilSym0,
   (:$), (:$$), (:$$$),
-  NilSym0, ConsSym0, ConsSym1, ConsSym2,
 
   (:++$$), (:++$), HeadSym0, HeadSym1, LastSym0, LastSym1,
   TailSym0, TailSym1, InitSym0, InitSym1, NullSym0, NullSym1,
@@ -497,11 +497,3 @@
 
   |])
 
--- The symbol []$ is clearly malformed, so we have to name this symbol
--- NilSym0
-type NilSym0      = '[]
-
--- If Nil has an alphanumeric symbol, we wouldn't want to leave Cons out...
-type ConsSym0     = (:$)
-type ConsSym1     = (:$$)
-type ConsSym2 a b = (:$$$) a b
diff --git a/src/Data/Singletons/Prelude/Ord.hs b/src/Data/Singletons/Prelude/Ord.hs
--- a/src/Data/Singletons/Prelude/Ord.hs
+++ b/src/Data/Singletons/Prelude/Ord.hs
@@ -67,13 +67,13 @@
         -- because the latter is often more expensive
     max x y = if x <= y then y else x
     min x y = if x <= y then x else y
-    {-# MINIMAL compare | (<=) #-}
+    -- Not handled by TH: {-# MINIMAL compare | (<=) #-}
   |])
 
 type family CaseOrdering (ord :: Ordering) (lt :: k) (eq :: k) (gt :: k) :: k
-type instance CaseOrdering LT lt eq gt = lt
-type instance CaseOrdering EQ lt eq gt = eq
-type instance CaseOrdering GT lt eq gt = gt
+type instance CaseOrdering 'LT lt eq gt = lt
+type instance CaseOrdering 'EQ lt eq gt = eq
+type instance CaseOrdering 'GT lt eq gt = gt
 
 class (kproxy ~ 'KProxy, SEq ('KProxy :: KProxy a))
       => SOrd (kproxy :: KProxy a) where
@@ -86,28 +86,28 @@
   sMin      :: forall (x :: a) (y :: a). Sing x -> Sing y -> Sing (Min x y)
 
   default sCompare :: forall (x :: a) (y :: a).
-                      (Compare x y ~ If (x :== y) EQ (If (x :<= y) LT GT))
+                      (Compare x y ~ If (x :== y) 'EQ (If (x :<= y) 'LT 'GT))
                    => Sing x -> Sing y -> Sing (Compare x y)
   sCompare x y = sIf (x %:== y) SEQ
                      (sIf (x %:<= y) SLT SGT)
 
   default (%:<) :: forall (x :: a) (y :: a).
-                   ((x :< y) ~ CaseOrdering (Compare x y) True False False)
+                   ((x :< y) ~ CaseOrdering (Compare x y) 'True 'False 'False)
                 => Sing x -> Sing y -> Sing (x :< y)
   x %:< y = case sCompare x y of { SLT -> STrue; SEQ -> SFalse; SGT -> SFalse }
 
   default (%:<=) :: forall (x :: a) (y :: a).
-                    ((x :<= y) ~ CaseOrdering (Compare x y) True True False)
+                    ((x :<= y) ~ CaseOrdering (Compare x y) 'True 'True 'False)
                  => Sing x -> Sing y -> Sing (x :<= y)
   x %:<= y = case sCompare x y of { SLT -> STrue; SEQ -> STrue; SGT -> SFalse }
 
   default (%:>) :: forall (x :: a) (y :: a).
-                   ((x :> y) ~ CaseOrdering (Compare x y) False False True)
+                   ((x :> y) ~ CaseOrdering (Compare x y) 'False 'False 'True)
                 => Sing x -> Sing y -> Sing (x :> y)
   x %:> y = case sCompare x y of { SLT -> SFalse; SEQ -> SFalse; SGT -> STrue }
 
   default (%:>=) :: forall (x :: a) (y :: a).
-                    ((x :>= y) ~ CaseOrdering (Compare x y) False True True)
+                    ((x :>= y) ~ CaseOrdering (Compare x y) 'False 'True 'True)
                  => Sing x -> Sing y -> Sing (x :>= y)
   x %:>= y = case sCompare x y of { SLT -> SFalse; SEQ -> STrue; SGT -> STrue }
 
diff --git a/src/Data/Singletons/Promote.hs b/src/Data/Singletons/Promote.hs
--- a/src/Data/Singletons/Promote.hs
+++ b/src/Data/Singletons/Promote.hs
@@ -12,9 +12,9 @@
 module Data.Singletons.Promote where
 
 import Language.Haskell.TH hiding ( Q, cxt )
-import Language.Haskell.TH.Syntax ( Quasi(..) )
+import Language.Haskell.TH.Syntax ( qNewName )
 import Language.Haskell.TH.Desugar
-import Language.Haskell.TH.Desugar.Sweeten
+import Language.Haskell.TH.Desugar.Lift ()
 import Data.Singletons.Names
 import Data.Singletons.Promote.Monad
 import Data.Singletons.Promote.Eq
@@ -33,52 +33,52 @@
 
 -- | Generate promoted definitions from a type that is already defined.
 -- This is generally only useful with classes.
-genPromotions :: Quasi q => [Name] -> q [Dec]
+genPromotions :: DsMonad q => [Name] -> q [Dec]
 genPromotions names = do
   checkForRep names
   infos <- mapM reifyWithWarning names
   dinfos <- mapM dsInfo infos
-  ddecs <- promoteM_ $ mapM_ promoteInfo dinfos
+  ddecs <- promoteM_ [] $ mapM_ promoteInfo dinfos
   return $ decsToTH ddecs
 
 -- | Promote every declaration given to the type level, retaining the originals.
-promote :: Quasi q => q [Dec] -> q [Dec]
+promote :: DsMonad q => q [Dec] -> q [Dec]
 promote qdec = do
   decls <- qdec
-  ddecls <- dsDecs decls
-  promDecls <- promoteM_ $ promoteDecs ddecls
+  ddecls <- withLocalDeclarations decls $ dsDecs decls
+  promDecls <- promoteM_ decls $ promoteDecs ddecls
   return $ decls ++ decsToTH promDecls
 
 -- | Promote each declaration, discarding the originals.
-promoteOnly :: Quasi q => q [Dec] -> q [Dec]
+promoteOnly :: DsMonad q => q [Dec] -> q [Dec]
 promoteOnly qdec = do
   decls  <- qdec
   ddecls <- dsDecs decls
-  promDecls <- promoteM_ $ promoteDecs ddecls
+  promDecls <- promoteM_ decls $ promoteDecs ddecls
   return $ decsToTH promDecls
 
 -- | Generate defunctionalization symbols for existing type family
-genDefunSymbols :: Quasi q => [Name] -> q [Dec]
+genDefunSymbols :: DsMonad q => [Name] -> q [Dec]
 genDefunSymbols names = do
   checkForRep names
   infos <- mapM (dsInfo <=< reifyWithWarning) names
-  decs <- promoteMDecs $ concatMapM defunInfo infos
+  decs <- promoteMDecs [] $ concatMapM defunInfo infos
   return $ decsToTH decs
 
 -- | Produce instances for '(:==)' (type-level equality) from the given types
-promoteEqInstances :: Quasi q => [Name] -> q [Dec]
+promoteEqInstances :: DsMonad q => [Name] -> q [Dec]
 promoteEqInstances = concatMapM promoteEqInstance
 
 -- | Produce instances for 'Compare' from the given types
-promoteOrdInstances :: Quasi q => [Name] -> q [Dec]
+promoteOrdInstances :: DsMonad q => [Name] -> q [Dec]
 promoteOrdInstances = concatMapM promoteOrdInstance
 
 -- | Produce instances for 'MinBound' and 'MaxBound' from the given types
-promoteBoundedInstances :: Quasi q => [Name] -> q [Dec]
+promoteBoundedInstances :: DsMonad q => [Name] -> q [Dec]
 promoteBoundedInstances = concatMapM promoteBoundedInstance
 
 -- | Produce an instance for '(:==)' (type-level equality) from the given type
-promoteEqInstance :: Quasi q => Name -> q [Dec]
+promoteEqInstance :: DsMonad q => Name -> q [Dec]
 promoteEqInstance name = do
   (_tvbs, cons) <- getDataD "I cannot make an instance of (:==) for it." name
   cons' <- mapM dsCon cons
@@ -93,7 +93,7 @@
 #endif
 
 -- | Produce an instance for 'Compare' from the given type
-promoteOrdInstance :: Quasi q => Name -> q [Dec]
+promoteOrdInstance :: DsMonad q => Name -> q [Dec]
 promoteOrdInstance name = do
   (_tvbs, cons) <- getDataD "I cannot make an instance of Ord for it." name
   cons' <- mapM dsCon cons
@@ -107,7 +107,7 @@
 #endif
 
 -- | Produce an instance for 'MinBound' and 'MaxBound' from the given type
-promoteBoundedInstance :: Quasi q => Name -> q [Dec]
+promoteBoundedInstance :: DsMonad q => Name -> q [Dec]
 promoteBoundedInstance name = do
   (_tvbs, cons) <- getDataD "I cannot make an instance of Bounded for it." name
   cons' <- mapM dsCon cons
@@ -327,7 +327,7 @@
     lookup_cls_tvb_names :: PrM [String]
     lookup_cls_tvb_names = case Map.lookup cls_name cls_tvb_env of
       Nothing -> do
-        m_dinfo <- qReifyMaybe pClsName
+        m_dinfo <- dsReify pClsName
         case m_dinfo of
           Just (DTyConI (DClassD _cxt _name cls_tvbs _fds _decs) _insts) -> do
             mapM extract_kv_name cls_tvbs
@@ -378,7 +378,7 @@
       Nothing -> do
           -- lookup the promoted name, just in case the term-level one
           -- isn't defined
-        m_dinfo <- qReifyMaybe proName
+        m_dinfo <- dsReify proName
         case m_dinfo of
           Just (DTyConI (DFamilyD _flav _name tvbs (Just res)) _insts) -> do
             arg_kis <- mapM (expect_just . extractTvbKind) tvbs
@@ -629,6 +629,7 @@
   (exp', ann_exp) <- promoteExp exp
   ty' <- promoteType ty
   return (DSigT exp' ty', ADSigE ann_exp ty)
+promoteExp (DStaticE _) = fail "Promoting static expressions not yet supported"
 
 promoteLit :: Monad m => Lit -> m DType
 promoteLit (IntegerL n)
diff --git a/src/Data/Singletons/Promote/Bounded.hs b/src/Data/Singletons/Promote/Bounded.hs
--- a/src/Data/Singletons/Promote/Bounded.hs
+++ b/src/Data/Singletons/Promote/Bounded.hs
@@ -15,13 +15,12 @@
 
 module Data.Singletons.Promote.Bounded where
 
-import Language.Haskell.TH.Syntax
 import Language.Haskell.TH.Desugar
 import Data.Singletons.Names
 import Data.Singletons.Util
 import Control.Monad
 
-mkBoundedTypeInstance :: Quasi q => DKind -> [DCon] -> q [DDec]
+mkBoundedTypeInstance :: DsMonad q => DKind -> [DCon] -> q [DDec]
 mkBoundedTypeInstance kind@(DConK name _) cons = do
   -- We can derive instance of Bounded if datatype is an enumeration (all
   -- constructors must be nullary) or has only one constructor. See Section 11
diff --git a/src/Data/Singletons/Promote/Eq.hs b/src/Data/Singletons/Promote/Eq.hs
--- a/src/Data/Singletons/Promote/Eq.hs
+++ b/src/Data/Singletons/Promote/Eq.hs
@@ -29,7 +29,7 @@
 #if __GLASGOW_HASKELL__ >= 707
 -- produce a closed type family helper and the instance
 -- for (:==) over the given list of ctors
-mkEqTypeInstance :: Quasi q => DKind -> [DCon] -> q [DDec]
+mkEqTypeInstance :: DsMonad q => DKind -> [DCon] -> q [DDec]
 mkEqTypeInstance kind cons = do
   helperName <- newUniqueName "Equals"
   aName <- qNewName "a"
@@ -50,7 +50,7 @@
                                      
   return [closedFam, inst]
 
-  where mk_branch :: Quasi q => DCon -> q DTySynEqn
+  where mk_branch :: DsMonad q => DCon -> q DTySynEqn
         mk_branch con = do
           let (name, numArgs) = extractNameArgs con
           lnames <- replicateM numArgs (qNewName "a")
@@ -63,7 +63,7 @@
               result = tyAll results
           return $ DTySynEqn [ltype, rtype] result
 
-        false_case :: Quasi q => q DTySynEqn
+        false_case :: DsMonad q => q DTySynEqn
         false_case = do
           lvar <- qNewName "a"
           rvar <- qNewName "b"
@@ -79,7 +79,7 @@
 #else
 
 -- produce the type instance for (:==) for the given pair of constructors
-mkEqTypeInstance :: Quasi q => (DCon, DCon) -> q DDec
+mkEqTypeInstance :: DsMonad q => (DCon, DCon) -> q DDec
 mkEqTypeInstance (c1, c2) =
   if c1 == c2
   then do
diff --git a/src/Data/Singletons/Promote/Monad.hs b/src/Data/Singletons/Promote/Monad.hs
--- a/src/Data/Singletons/Promote/Monad.hs
+++ b/src/Data/Singletons/Promote/Monad.hs
@@ -11,7 +11,6 @@
 
 {-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving, CPP,
              FlexibleContexts, TypeFamilies, KindSignatures #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}   -- we have orphan Quasi instances
 
 module Data.Singletons.Promote.Monad (
   PrM, promoteM, promoteM_, promoteMDecs, VarPromotions,
@@ -26,75 +25,64 @@
 import Language.Haskell.TH.Syntax hiding ( lift )
 import Language.Haskell.TH.Desugar
 import Data.Singletons.Util
-import Control.Applicative
 import Data.Singletons.Names
 import Data.Singletons.Syntax
 
+#if __GLASGOW_HASKELL__ < 709
+import Control.Applicative
+#endif
+
 type LetExpansions = Map Name DType  -- from **term-level** name
 
 -- environment during promotion
 data PrEnv =
   PrEnv { pr_lambda_bound :: Map Name Name
         , pr_let_bound    :: LetExpansions
+        , pr_local_decls  :: [Dec]
         }
 
 emptyPrEnv :: PrEnv
 emptyPrEnv = PrEnv { pr_lambda_bound = Map.empty
-                   , pr_let_bound    = Map.empty }
+                   , pr_let_bound    = Map.empty
+                   , pr_local_decls  = [] }
 
 -- the promotion monad
 newtype PrM a = PrM (ReaderT PrEnv (WriterT [DDec] Q) a)
-  deriving ( Functor, Applicative, Monad, Quasi
+  deriving ( Functor, Applicative, Monad
            , MonadReader PrEnv, MonadWriter [DDec] )
 
--- we need Quasi instances for ReaderT and WriterT for the above to work.
+liftPrM :: Q a -> PrM a
+liftPrM = PrM . lift . lift
 
-instance (Quasi q, Monoid m) => Quasi (WriterT m q) where
-  qNewName          = lift `comp1` qNewName
-  qReport           = lift `comp2` qReport
-  qLookupName       = lift `comp2` qLookupName
-  qReify            = lift `comp1` qReify
-  qReifyInstances   = lift `comp2` qReifyInstances
-  qLocation         = lift qLocation
-  qRunIO            = lift `comp1` qRunIO
-  qAddDependentFile = lift `comp1` qAddDependentFile
+instance Quasi PrM where
+  qNewName          = liftPrM `comp1` qNewName
+  qReport           = liftPrM `comp2` qReport
+  qLookupName       = liftPrM `comp2` qLookupName
+  qReify            = liftPrM `comp1` qReify
+  qReifyInstances   = liftPrM `comp2` qReifyInstances
+  qLocation         = liftPrM qLocation
+  qRunIO            = liftPrM `comp1` qRunIO
+  qAddDependentFile = liftPrM `comp1` qAddDependentFile
 #if __GLASGOW_HASKELL__ >= 707
-  qReifyRoles       = lift `comp1` qReifyRoles
-  qReifyAnnotations = lift `comp1` qReifyAnnotations
-  qReifyModule      = lift `comp1` qReifyModule
-  qAddTopDecls      = lift `comp1` qAddTopDecls
-  qAddModFinalizer  = lift `comp1` qAddModFinalizer
-  qGetQ             = lift qGetQ
-  qPutQ             = lift `comp1` qPutQ
+  qReifyRoles       = liftPrM `comp1` qReifyRoles
+  qReifyAnnotations = liftPrM `comp1` qReifyAnnotations
+  qReifyModule      = liftPrM `comp1` qReifyModule
+  qAddTopDecls      = liftPrM `comp1` qAddTopDecls
+  qAddModFinalizer  = liftPrM `comp1` qAddModFinalizer
+  qGetQ             = liftPrM qGetQ
+  qPutQ             = liftPrM `comp1` qPutQ
 #endif
 
-  qRecover handler body = do
-    (result, aux) <- lift $ qRecover (runWriterT handler) (runWriterT body)
+  qRecover (PrM handler) (PrM body) = do
+    env <- ask
+    (result, aux) <- liftPrM $
+                     qRecover (runWriterT $ runReaderT handler env)
+                              (runWriterT $ runReaderT body env)
     tell aux
     return result
 
-instance Quasi q => Quasi (ReaderT r q) where
-  qNewName          = lift `comp1` qNewName
-  qReport           = lift `comp2` qReport
-  qLookupName       = lift `comp2` qLookupName
-  qReify            = lift `comp1` qReify
-  qReifyInstances   = lift `comp2` qReifyInstances
-  qLocation         = lift qLocation
-  qRunIO            = lift `comp1` qRunIO
-  qAddDependentFile = lift `comp1` qAddDependentFile
-#if __GLASGOW_HASKELL__ >= 707
-  qReifyRoles       = lift `comp1` qReifyRoles
-  qReifyAnnotations = lift `comp1` qReifyAnnotations
-  qReifyModule      = lift `comp1` qReifyModule
-  qAddTopDecls      = lift `comp1` qAddTopDecls
-  qAddModFinalizer  = lift `comp1` qAddModFinalizer
-  qGetQ             = lift qGetQ
-  qPutQ             = lift `comp1` qPutQ
-#endif
-
-  qRecover handler body = do
-    env <- ask
-    lift $ qRecover (runReaderT handler env) (runReaderT body env)
+instance DsMonad PrM where
+  localDeclarations = asks pr_local_decls
 
 -- return *type-level* names
 allLocals :: MonadReader PrEnv m => m [Name]
@@ -139,21 +127,21 @@
     Just ty -> return ty
     Nothing -> return $ promoteValRhs n
 
-promoteM :: Quasi q => PrM a -> q (a, [DDec])
-promoteM (PrM rdr) =
-  let wr = runReaderT rdr emptyPrEnv
+promoteM :: DsMonad q => [Dec] -> PrM a -> q (a, [DDec])
+promoteM locals (PrM rdr) = do
+  other_locals <- localDeclarations
+  let wr = runReaderT rdr (emptyPrEnv { pr_local_decls = other_locals ++ locals })
       q  = runWriterT wr
-  in
   runQ q
 
-promoteM_ :: Quasi q => PrM () -> q [DDec]
-promoteM_ thing = do
-  ((), decs) <- promoteM thing
+promoteM_ :: DsMonad q => [Dec] -> PrM () -> q [DDec]
+promoteM_ locals thing = do
+  ((), decs) <- promoteM locals thing
   return decs
 
 -- promoteM specialized to [DDec]
-promoteMDecs :: Quasi q => PrM [DDec] -> q [DDec]
-promoteMDecs thing = do
-  (decs1, decs2) <- promoteM thing
+promoteMDecs :: DsMonad q => [Dec] -> PrM [DDec] -> q [DDec]
+promoteMDecs locals thing = do
+  (decs1, decs2) <- promoteM locals thing
   return $ decs1 ++ decs2
 
diff --git a/src/Data/Singletons/Promote/Ord.hs b/src/Data/Singletons/Promote/Ord.hs
--- a/src/Data/Singletons/Promote/Ord.hs
+++ b/src/Data/Singletons/Promote/Ord.hs
@@ -20,7 +20,7 @@
 import Data.Singletons.Names
 import Data.Singletons.Util
 
-mkOrdTypeInstance :: Quasi q => DKind -> [DCon] -> q [DDec]
+mkOrdTypeInstance :: DsMonad q => DKind -> [DCon] -> q [DDec]
 mkOrdTypeInstance kind cons = do
   let tagged_cons = zip cons [1..]
       con_pairs   = [ (c1, c2) | c1 <- tagged_cons, c2 <- tagged_cons ]
@@ -31,7 +31,7 @@
                                tyfam_insts
   return [pord_inst]
 
-mkOrdTySynEqn :: Quasi q => ((DCon, Int), (DCon, Int)) -> q DTySynEqn
+mkOrdTySynEqn :: DsMonad q => ((DCon, Int), (DCon, Int)) -> q DTySynEqn
 mkOrdTySynEqn ((c1, n1), (c2, n2)) = do
   let DCon _tvbs1 _cxt1 con_name1 con_fields1 = c1
       DCon _tvbs2 _cxt2 con_name2 con_fields2 = c2
@@ -119,7 +119,7 @@
 ---- (although this implementation requires that we actually compare all fields
 ---- at the call site).
 
-mkOrdTypeInstance :: Quasi q => DKind -> [DCon] -> q [DDec]
+mkOrdTypeInstance :: DsMonad q => DKind -> [DCon] -> q [DDec]
 mkOrdTypeInstance kind cons = do
   let taggedCons   = zip cons [1..]
       l            = length cons
@@ -151,7 +151,7 @@
                                                     [DVarT aName, DVarT bName]))
   return (closedFam : compareInst : eqDecs)
 
-  where mkCompareEqn :: Quasi q => Int -> ((DCon, Int), (DCon, Int))
+  where mkCompareEqn :: DsMonad q => Int -> ((DCon, Int), (DCon, Int))
                                 -> QWithAux [DDec] q DTySynEqn
         mkCompareEqn half ((con1, tag1), (con2, tag2))
             | tag1 > tag2 && tag1 <= half =
@@ -169,7 +169,7 @@
         ltT = DConT ordLTSymName
         gtT = DConT ordGTSymName
 
-        mkCompareEqnHelper :: Quasi q => DCon -> Maybe DCon -> DType -> q DTySynEqn
+        mkCompareEqnHelper :: DsMonad q => DCon -> Maybe DCon -> DType -> q DTySynEqn
         mkCompareEqnHelper con1 con2 result = do
             let (name1, numArgs1) = extractNameArgs con1
             (name2, numArgs2) <- case con2 of
@@ -184,7 +184,7 @@
                 rtype = foldType name2 rvars
             return $ DTySynEqn [ltype, rtype] result
 
-        mkCompareEqual :: Quasi q => DCon -> QWithAux [DDec] q DTySynEqn
+        mkCompareEqual :: DsMonad q => DCon -> QWithAux [DDec] q DTySynEqn
         mkCompareEqual con = do
             let (name, numArgs) = extractNameArgs con
             case numArgs of
@@ -208,7 +208,7 @@
                     call = foldType (DConT helperName) callParams
                 return $ DTySynEqn [ltype, rtype] call
             where
-                  buildHelperTyFam :: Quasi q => Int -> Name -> QWithAux [DDec] q ()
+                  buildHelperTyFam :: DsMonad q => Int -> Name -> QWithAux [DDec] q ()
                   buildHelperTyFam numArgs helperName = do
                     let orderingKCon = DConK orderingName []
                     (patterns, results) <- buildEqnPats numArgs ([[]], [eqT])
@@ -222,7 +222,7 @@
                     addElement closedFam
                     return ()
 
-                  buildEqnPats :: Quasi q => Int -> ([[DType]], [DType])
+                  buildEqnPats :: DsMonad q => Int -> ([[DType]], [DType])
                                           -> q ([[DType]], [DType])
                   buildEqnPats 0 acc = return acc
                   buildEqnPats n acc = do
diff --git a/src/Data/Singletons/Single.hs b/src/Data/Singletons/Single.hs
--- a/src/Data/Singletons/Single.hs
+++ b/src/Data/Singletons/Single.hs
@@ -12,7 +12,7 @@
 
 import Prelude hiding ( exp )
 import Language.Haskell.TH hiding ( cxt )
-import Language.Haskell.TH.Syntax (Quasi(..))
+import Language.Haskell.TH.Syntax ( qNewName )
 import Data.Singletons.Util
 import Data.Singletons.Promote
 import Data.Singletons.Promote.Monad ( promoteM, promoteM_ )
@@ -23,7 +23,6 @@
 import Data.Singletons.Single.Eq
 import Data.Singletons.Syntax
 import Language.Haskell.TH.Desugar
-import Language.Haskell.TH.Desugar.Sweeten
 import qualified Data.Map.Strict as Map
 import Data.Map.Strict ( Map )
 import Control.Monad
@@ -69,7 +68,7 @@
 -- > $(genSingletons [''Bool, ''Maybe, ''Either, ''[]])
 --
 -- to generate singletons for Prelude types.
-genSingletons :: Quasi q => [Name] -> q [Dec]
+genSingletons :: DsMonad q => [Name] -> q [Dec]
 genSingletons names = do
   checkForRep names
   ddecs <- concatMapM (singInfo <=< dsInfo <=< reifyWithWarning) names
@@ -79,7 +78,7 @@
 -- the original declarations.
 -- See <http://www.cis.upenn.edu/~eir/packages/singletons/README.html> for
 -- further explanation.
-singletons :: Quasi q => q [Dec] -> q [Dec]
+singletons :: DsMonad q => q [Dec] -> q [Dec]
 singletons qdecs = do
   decs <- qdecs
   singDecs <- wrapDesugar singTopLevelDecs decs
@@ -87,15 +86,15 @@
 
 -- | Make promoted and singleton versions of all declarations given, discarding
 -- the original declarations.
-singletonsOnly :: Quasi q => q [Dec] -> q [Dec]
+singletonsOnly :: DsMonad q => q [Dec] -> q [Dec]
 singletonsOnly = (>>= wrapDesugar singTopLevelDecs)
 
 -- | Create instances of 'SEq' and type-level '(:==)' for each type in the list
-singEqInstances :: Quasi q => [Name] -> q [Dec]
+singEqInstances :: DsMonad q => [Name] -> q [Dec]
 singEqInstances = concatMapM singEqInstance
 
 -- | Create instance of 'SEq' and type-level '(:==)' for the given type
-singEqInstance :: Quasi q => Name -> q [Dec]
+singEqInstance :: DsMonad q => Name -> q [Dec]
 singEqInstance name = do
   promotion <- promoteEqInstance name
   dec <- singEqualityInstance sEqClassDesc name
@@ -103,12 +102,12 @@
 
 -- | Create instances of 'SEq' (only -- no instance for '(:==)', which 'SEq' generally
 -- relies on) for each type in the list
-singEqInstancesOnly :: Quasi q => [Name] -> q [Dec]
+singEqInstancesOnly :: DsMonad q => [Name] -> q [Dec]
 singEqInstancesOnly = concatMapM singEqInstanceOnly
 
 -- | Create instances of 'SEq' (only -- no instance for '(:==)', which 'SEq' generally
 -- relies on) for the given type
-singEqInstanceOnly :: Quasi q => Name -> q [Dec]
+singEqInstanceOnly :: DsMonad q => Name -> q [Dec]
 singEqInstanceOnly name = singEqualityInstance sEqClassDesc name
 
 -- | Create instances of 'SDecide' for each type in the list.
@@ -116,7 +115,7 @@
 -- Note that, due to a bug in GHC 7.6.3 (and lower) optimizing instances
 -- for SDecide can make GHC hang. You may want to put
 -- @{-# OPTIONS_GHC -O0 #-}@ in your file.
-singDecideInstances :: Quasi q => [Name] -> q [Dec]
+singDecideInstances :: DsMonad q => [Name] -> q [Dec]
 singDecideInstances = concatMapM singDecideInstance
 
 -- | Create instance of 'SDecide' for the given type.
@@ -124,11 +123,11 @@
 -- Note that, due to a bug in GHC 7.6.3 (and lower) optimizing instances
 -- for SDecide can make GHC hang. You may want to put
 -- @{-# OPTIONS_GHC -O0 #-}@ in your file.
-singDecideInstance :: Quasi q => Name -> q [Dec]
+singDecideInstance :: DsMonad q => Name -> q [Dec]
 singDecideInstance name = singEqualityInstance sDecideClassDesc name
 
 -- generalized function for creating equality instances
-singEqualityInstance :: Quasi q => EqualityClassDesc q -> Name -> q [Dec]
+singEqualityInstance :: DsMonad q => EqualityClassDesc q -> Name -> q [Dec]
 singEqualityInstance desc@(_, className, _) name = do
   (tvbs, cons) <- getDataD ("I cannot make an instance of " ++
                             show className ++ " for it.") name
@@ -138,13 +137,13 @@
       kind = DConK name tyvars
   aName <- qNewName "a"
   let aVar = DVarT aName
-  (scons, _) <- singM $ mapM (singCtor aVar) dcons
+  (scons, _) <- singM [] $ mapM (singCtor aVar) dcons
   eqInstance <- mkEqualityInstance kind scons desc
   return $ decToTH eqInstance
 
-singInfo :: Quasi q => DInfo -> q [DDec]
+singInfo :: DsMonad q => DInfo -> q [DDec]
 singInfo (DTyConI dec Nothing) = do -- TODO: document this special case
-  singTopLevelDecs [dec]
+  singTopLevelDecs [] [dec]
 singInfo (DTyConI {}) =
   fail "Singling of things with instances not yet supported" -- TODO: fix
 singInfo (DPrimTyConI _name _numArgs _unlifted) =
@@ -154,8 +153,8 @@
 singInfo (DTyVarI _name _ty) =
   fail "Singling of type variable info not supported"
 
-singTopLevelDecs :: Quasi q => [DDec] -> q [DDec]
-singTopLevelDecs decls = do
+singTopLevelDecs :: DsMonad q => [Dec] -> [DDec] -> q [DDec]
+singTopLevelDecs locals decls = do
   PDecs { pd_let_decs              = letDecls
         , pd_class_decs            = classes
         , pd_instance_decs         = insts
@@ -164,9 +163,10 @@
   when (not (null classes) || not (null insts)) $
     qReportError "Classes and instances may not yet be made into singletons."
 
-  dataDecls' <- promoteM_ $ promoteDataDecs datas
-  ((_, letDecEnv), letDecls') <- promoteM $ promoteLetDecs noPrefix letDecls
-  singDecsM $ do
+  dataDecls' <- promoteM_ locals $ promoteDataDecs datas
+  ((_, letDecEnv), letDecls') <- promoteM locals $
+                                 promoteLetDecs noPrefix letDecls
+  singDecsM locals $ do
     let letBinds = concatMap buildDataLets datas
                 ++ concatMap buildMethLets classes
     (newLetDecls, newDataDecls) <- bindLets letBinds $
diff --git a/src/Data/Singletons/Single/Eq.hs b/src/Data/Singletons/Single/Eq.hs
--- a/src/Data/Singletons/Single/Eq.hs
+++ b/src/Data/Singletons/Single/Eq.hs
@@ -17,12 +17,12 @@
 -- making the SEq instance and the SDecide instance are rather similar,
 -- so we generalize
 type EqualityClassDesc q = ((DCon, DCon) -> q DClause, Name, Name)
-sEqClassDesc, sDecideClassDesc :: Quasi q => EqualityClassDesc q
+sEqClassDesc, sDecideClassDesc :: DsMonad q => EqualityClassDesc q
 sEqClassDesc = (mkEqMethClause, sEqClassName, sEqMethName)
 sDecideClassDesc = (mkDecideMethClause, sDecideClassName, sDecideMethName)
 
 -- pass the *singleton* constructors, not the originals
-mkEqualityInstance :: Quasi q => DKind -> [DCon]
+mkEqualityInstance :: DsMonad q => DKind -> [DCon]
                    -> EqualityClassDesc q -> q DDec
 mkEqualityInstance k ctors (mkMeth, className, methName) = do
   let ctorPairs = [ (c1, c2) | c1 <- ctors, c2 <- ctors ]
@@ -42,12 +42,12 @@
         getKindVars other             =
           error ("getKindVars sees an unusual kind: " ++ show other)
 
-        mkEmptyMethClauses :: Quasi q => q [DClause]
+        mkEmptyMethClauses :: DsMonad q => q [DClause]
         mkEmptyMethClauses = do
           a <- qNewName "a"
           return [DClause [DVarPa a, DWildPa] (DCaseE (DVarE a) emptyMatches)]
 
-mkEqMethClause :: Quasi q => (DCon, DCon) -> q DClause
+mkEqMethClause :: DsMonad q => (DCon, DCon) -> q DClause
 mkEqMethClause (c1, c2)
   | lname == rname = do
     lnames <- replicateM lNumArgs (qNewName "a")
@@ -73,7 +73,7 @@
         (lname, lNumArgs) = extractNameArgs c1
         (rname, rNumArgs) = extractNameArgs c2
 
-mkDecideMethClause :: Quasi q => (DCon, DCon) -> q DClause
+mkDecideMethClause :: DsMonad q => (DCon, DCon) -> q DClause
 mkDecideMethClause (c1, c2)
   | lname == rname =
     if lNumArgs == 0
diff --git a/src/Data/Singletons/Single/Monad.hs b/src/Data/Singletons/Single/Monad.hs
--- a/src/Data/Singletons/Single/Monad.hs
+++ b/src/Data/Singletons/Single/Monad.hs
@@ -9,7 +9,7 @@
 -}
 
 {-# LANGUAGE GeneralizedNewtypeDeriving, ParallelListComp,
-             TemplateHaskell #-}
+             TemplateHaskell, CPP #-}
 
 module Data.Singletons.Single.Monad (
   SgM, bindLets, bindTyVars, bindTyVarsClause, lookupVarE, lookupConE,
@@ -27,24 +27,60 @@
 import Data.Singletons
 import Language.Haskell.TH.Syntax hiding ( lift )
 import Language.Haskell.TH.Desugar
-import Control.Applicative
 import Control.Monad.Reader
 import Control.Monad.Writer
 
+#if __GLASGOW_HASKELL__ < 709
+import Control.Applicative
+#endif
+
 -- environment during singling
 data SgEnv =
-  SgEnv { sg_let_binds :: Map Name DExp   -- from the *original* name
+  SgEnv { sg_let_binds   :: Map Name DExp   -- from the *original* name
+        , sg_local_decls :: [Dec]
         }
 
 emptySgEnv :: SgEnv
-emptySgEnv = SgEnv { sg_let_binds = Map.empty
+emptySgEnv = SgEnv { sg_let_binds   = Map.empty
+                   , sg_local_decls = []
                    }
 
 -- the singling monad
 newtype SgM a = SgM (ReaderT SgEnv (WriterT [DDec] Q) a)
-  deriving ( Functor, Applicative, Monad, Quasi
+  deriving ( Functor, Applicative, Monad
            , MonadReader SgEnv, MonadWriter [DDec] )
 
+liftSgM :: Q a -> SgM a
+liftSgM = SgM . lift . lift
+
+instance Quasi SgM where
+  qNewName          = liftSgM `comp1` qNewName
+  qReport           = liftSgM `comp2` qReport
+  qLookupName       = liftSgM `comp2` qLookupName
+  qReify            = liftSgM `comp1` qReify
+  qReifyInstances   = liftSgM `comp2` qReifyInstances
+  qLocation         = liftSgM qLocation
+  qRunIO            = liftSgM `comp1` qRunIO
+  qAddDependentFile = liftSgM `comp1` qAddDependentFile
+  qReifyRoles       = liftSgM `comp1` qReifyRoles
+  qReifyAnnotations = liftSgM `comp1` qReifyAnnotations
+  qReifyModule      = liftSgM `comp1` qReifyModule
+  qAddTopDecls      = liftSgM `comp1` qAddTopDecls
+  qAddModFinalizer  = liftSgM `comp1` qAddModFinalizer
+  qGetQ             = liftSgM qGetQ
+  qPutQ             = liftSgM `comp1` qPutQ
+
+  qRecover (SgM handler) (SgM body) = do
+    env <- ask
+    (result, aux) <- liftSgM $
+                     qRecover (runWriterT $ runReaderT handler env)
+                              (runWriterT $ runReaderT body env)
+    tell aux
+    return result
+
+instance DsMonad SgM where
+  localDeclarations = asks sg_local_decls
+
 bindLets :: [(Name, DExp)] -> SgM a -> SgM a
 bindLets lets1 =
   local (\env@(SgEnv { sg_let_binds = lets2 }) ->
@@ -142,7 +178,7 @@
   case Map.lookup name letExpansions of
     Nothing -> do
       -- try to get it from the global context
-      m_dinfo <- qReifyMaybe sName
+      m_dinfo <- dsReify sName
       case m_dinfo of
         Just (DVarI _ ty _ _) ->
           let num_args = countArgs ty in
@@ -180,14 +216,14 @@
   in
   (unwrap_fun `DAppE` proxyFor ty `DAppE`)
 
-singM :: Quasi q => SgM a -> q (a, [DDec])
-singM (SgM rdr) =
-  let wr = runReaderT rdr emptySgEnv
+singM :: DsMonad q => [Dec] -> SgM a -> q (a, [DDec])
+singM locals (SgM rdr) = do
+  other_locals <- localDeclarations
+  let wr = runReaderT rdr (emptySgEnv { sg_local_decls = other_locals ++ locals })
       q  = runWriterT wr
-  in
   runQ q
 
-singDecsM :: Quasi q => SgM [DDec] -> q [DDec]
-singDecsM thing = do
-  (decs1, decs2) <- singM thing
+singDecsM :: DsMonad q => [Dec] -> SgM [DDec] -> q [DDec]
+singDecsM locals thing = do
+  (decs1, decs2) <- singM locals thing
   return $ decs1 ++ decs2
diff --git a/src/Data/Singletons/Syntax.hs b/src/Data/Singletons/Syntax.hs
--- a/src/Data/Singletons/Syntax.hs
+++ b/src/Data/Singletons/Syntax.hs
@@ -18,7 +18,6 @@
 import Language.Haskell.TH.Syntax
 import Language.Haskell.TH.Desugar
 import Language.Haskell.TH.Ppr
-import Language.Haskell.TH.Desugar.Sweeten
 import Data.Map.Strict ( Map )
 import qualified Data.Map.Strict as Map
 import Data.Maybe
@@ -117,6 +116,10 @@
 
 data AnnotationFlag = Annotated | Unannotated
 
+-- these will be promoted a lot!
+type Annotated = 'Annotated
+type Unannotated = 'Unannotated
+
 type family IfAnn (ann :: AnnotationFlag) (yes :: k) (no :: k) :: k
 type instance IfAnn Annotated   yes no = yes
 type instance IfAnn Unannotated yes no = no
@@ -155,7 +158,7 @@
 emptyLetDecEnv :: ULetDecEnv
 emptyLetDecEnv = mempty
 
-buildLetDecEnv :: Quasi q => [DLetDec] -> q ULetDecEnv
+buildLetDecEnv :: DsMonad q => [DLetDec] -> q ULetDecEnv
 buildLetDecEnv = go emptyLetDecEnv
   where
     go acc [] = return acc
diff --git a/src/Data/Singletons/TH.hs b/src/Data/Singletons/TH.hs
--- a/src/Data/Singletons/TH.hs
+++ b/src/Data/Singletons/TH.hs
@@ -78,11 +78,9 @@
 import Data.Singletons.TypeLits
 import Data.Singletons.SuppressUnusedWarnings
 import Language.Haskell.TH.Desugar
-import Language.Haskell.TH.Desugar.Sweeten
 
 import GHC.Exts
 import Language.Haskell.TH
-import Language.Haskell.TH.Syntax ( Quasi(..) )
 import Data.Singletons.Util
 import Control.Applicative
 
@@ -90,13 +88,13 @@
 -- is identical. This may be useful if the type-checker requires knowledge of which
 -- constructor is used to satisfy equality or type-class constraints, but where
 -- each constructor is treated the same.
-cases :: Quasi q
+cases :: DsMonad q
       => Name        -- ^ The head of the type of the scrutinee. (Like @''Maybe@ or @''Bool@.)
       -> q Exp       -- ^ The scrutinee, in a Template Haskell quote
       -> q Exp       -- ^ The body, in a Template Haskell quote
       -> q Exp
 cases tyName expq bodyq = do
-  info <- reifyWithWarning tyName
+  info <- reifyWithLocals tyName
   dinfo <- dsInfo info
   case dinfo of
     DTyConI (DDataD _ _ _ _ ctors _) _ -> fmap expToTH $ buildCases ctors
diff --git a/src/Data/Singletons/TypeRepStar.hs b/src/Data/Singletons/TypeRepStar.hs
--- a/src/Data/Singletons/TypeRepStar.hs
+++ b/src/Data/Singletons/TypeRepStar.hs
@@ -88,7 +88,7 @@
 
 -- everything below here is private and dirty. Don't look!
 
-newtype DI = Don'tInstantiate (Typeable a => Sing a)
+newtype DI = Don'tInstantiate (forall a. Typeable a => Sing a)
 dirty_mk_STypeRep :: TypeRep -> SomeSing ('KProxy :: KProxy *)
 dirty_mk_STypeRep rep =
 #if __GLASGOW_HASKELL__ >= 707
diff --git a/src/Data/Singletons/Util.hs b/src/Data/Singletons/Util.hs
--- a/src/Data/Singletons/Util.hs
+++ b/src/Data/Singletons/Util.hs
@@ -46,58 +46,25 @@
              , ''(,,,,,,)
             ]
 
-qReifyMaybe :: Quasi q => Name -> q (Maybe DInfo)
-qReifyMaybe name = do
-  m_info <- qRecover (return Nothing) (fmap Just $ qReify name)
-  traverse dsInfo m_info
-
--- like reportWarning, but generalized to any Quasi
-qReportWarning :: Quasi q => String -> q ()
+-- like reportWarning, but generalized to any DsMonad
+qReportWarning :: DsMonad q => String -> q ()
 qReportWarning = qReport False
 
--- like reportError, but generalized to any Quasi
-qReportError :: Quasi q => String -> q ()
+-- like reportError, but generalized to any DsMonad
+qReportError :: DsMonad q => String -> q ()
 qReportError = qReport True
 
-checkForRep :: Quasi q => [Name] -> q ()
+checkForRep :: DsMonad q => [Name] -> q ()
 checkForRep names =
   when (any ((== "Rep") . nameBase) names)
     (fail $ "A data type named <<Rep>> is a special case.\n" ++
             "Promoting it will not work as expected.\n" ++
             "Please choose another name for your data type.")
 
-checkForRepInDecls :: Quasi q => [DDec] -> q ()
+checkForRepInDecls :: DsMonad q => [DDec] -> q ()
 checkForRepInDecls decls =
   checkForRep (allNamesIn decls)
 
--- extract the degree of a tuple
-tupleDegree_maybe :: String -> Maybe Int
-tupleDegree_maybe s = do
-  '(' : s1 <- return s
-  (commas, ")") <- return $ span (== ',') s1
-  let degree
-        | "" <- commas = 0
-        | otherwise    = length commas + 1
-  return degree
-
--- extract the degree of a tuple name
-tupleNameDegree_maybe :: Name -> Maybe Int
-tupleNameDegree_maybe = tupleDegree_maybe . nameBase
-
--- extract the degree of an unboxed tuple
-unboxedTupleDegree_maybe :: String -> Maybe Int
-unboxedTupleDegree_maybe s = do
-  '(' : '#' : s1 <- return s
-  (commas, "#)") <- return $ span (== ',') s1
-  let degree
-        | "" <- commas = 0
-        | otherwise    = length commas + 1
-  return degree
-
--- extract the degree of a tuple name
-unboxedTupleNameDegree_maybe :: Name -> Maybe Int
-unboxedTupleNameDegree_maybe = unboxedTupleDegree_maybe . nameBase
-
 tysOfConFields :: DConFields -> [DType]
 tysOfConFields (DNormalC stys) = map snd stys
 tysOfConFields (DRecC vstys)   = map (\(_,_,ty) -> ty) vstys
@@ -177,7 +144,7 @@
 extractTvbName (DKindedTV n _) = n
 
 -- use the kind provided, or make a fresh kind variable
-inferKind :: Quasi q => Maybe DKind -> q (Maybe DKind)
+inferKind :: DsMonad q => Maybe DKind -> q (Maybe DKind)
 inferKind (Just k) = return $ Just k
 #if __GLASGOW_HASKELL__ < 707
 inferKind Nothing = do
@@ -250,18 +217,17 @@
   DCaseE (mkTupleDExp scruts) [DMatch (mkTupleDPat pats) body]
 
 -- Make a desugar function into a TH function.
-wrapDesugar :: (Desugar th ds, Quasi q) => (ds -> q ds) -> th -> q th
+wrapDesugar :: (Desugar th ds, DsMonad q) => (th -> ds -> q ds) -> th -> q th
 wrapDesugar f th = do
   ds <- desugar th
-  fmap sweeten $ f ds
+  fmap sweeten $ f th ds
 
 -- a monad transformer for writing a monoid alongside returning a Q
 newtype QWithAux m q a = QWA { runQWA :: WriterT m q a }
-  deriving (Functor, Applicative, Monad, MonadTrans, MonadWriter m)
-
-deriving instance (Monoid m, MonadReader r q) => MonadReader r (QWithAux m q)
+  deriving ( Functor, Applicative, Monad, MonadTrans
+           , MonadWriter m, MonadReader r )
 
--- make a Quasi instance for easy lifting
+-- make a DsMonad instance for easy lifting
 instance (Quasi q, Monoid m) => Quasi (QWithAux m q) where
   qNewName          = lift `comp1` qNewName
   qReport           = lift `comp2` qReport
@@ -285,6 +251,9 @@
     (result, aux) <- lift $ qRecover (evalForPair exp) (evalForPair handler)
     tell aux
     return result
+
+instance (DsMonad q, Monoid m) => DsMonad (QWithAux m q) where
+  localDeclarations = lift localDeclarations
 
 -- helper functions for composition
 comp1 :: (b -> c) -> (a -> b) -> a -> c
diff --git a/tests/SingletonsTestSuiteUtils.hs b/tests/SingletonsTestSuiteUtils.hs
--- a/tests/SingletonsTestSuiteUtils.hs
+++ b/tests/SingletonsTestSuiteUtils.hs
@@ -26,6 +26,8 @@
 import Data.Version                                  ( showVersion               )
 import System.IO.Unsafe                              ( unsafePerformIO           )
 
+#include "../dist/build/autogen/cabal_macros.h"
+
 -- Some infractructure for handling external process errors
 data ProcessException = ProcessException String deriving (Typeable)
 
@@ -70,7 +72,11 @@
 ghcOpts = [
     "-v0"
   , "-c"
+#if __GLASGOW_HASKELL__ < 709
   , "-package-name singletons-" ++ singletonsVersion -- See Note [-package-name hack]
+#else
+  , "-this-package-key " ++ CURRENT_PACKAGE_KEY
+#endif
   , "-ddump-splices"
   , "-dsuppress-uniques"
   , "-fforce-recomp"
diff --git a/tests/compile-and-dump/GradingClient/Database.ghc78.template b/tests/compile-and-dump/GradingClient/Database.ghc78.template
--- a/tests/compile-and-dump/GradingClient/Database.ghc78.template
+++ b/tests/compile-and-dump/GradingClient/Database.ghc78.template
@@ -25,12 +25,12 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
     data SuccSym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply SuccSym0 arg)) (KindOf (SuccSym1 arg)) =>
+      = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) =>
         SuccSym0KindInference
     type instance Apply SuccSym0 l = SuccSym1 l
     data instance Sing (z :: Nat)
-      = (GHC.Types.~) z Zero => SZero |
-        forall (n :: Nat). (GHC.Types.~) z (Succ n) => SSucc (Sing n)
+      = z ~ Zero => SZero |
+        forall (n :: Nat). z ~ Succ n => SSucc (Sing n)
     type SNat (z :: Nat) = Sing z
     instance SingKind (KProxy :: KProxy Nat) where
       type DemoteRep (KProxy :: KProxy Nat) = Nat
@@ -188,14 +188,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) VECSym1KindInference GHC.Tuple.())
     data VECSym1 (l :: U) (l :: TyFun Nat U)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (VECSym1 l) arg)) (KindOf (VECSym2 l arg)) =>
+      = forall arg. KindOf (Apply (VECSym1 l) arg) ~ KindOf (VECSym2 l arg) =>
         VECSym1KindInference
     type instance Apply (VECSym1 l) l = VECSym2 l l
     instance SuppressUnusedWarnings VECSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) VECSym0KindInference GHC.Tuple.())
     data VECSym0 (l :: TyFun U (TyFun Nat U -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply VECSym0 arg)) (KindOf (VECSym1 arg)) =>
+      = forall arg. KindOf (Apply VECSym0 arg) ~ KindOf (VECSym1 arg) =>
         VECSym0KindInference
     type instance Apply VECSym0 l = VECSym1 l
     type family Equals_0123456789 (a :: AChar)
@@ -260,7 +260,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) AttrSym1KindInference GHC.Tuple.())
     data AttrSym1 (l :: GHC.Types.[] AChar) (l :: TyFun U Attribute)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (AttrSym1 l) arg)) (KindOf (AttrSym2 l arg)) =>
+      = forall arg. KindOf (Apply (AttrSym1 l) arg) ~ KindOf (AttrSym2 l arg) =>
         AttrSym1KindInference
     type instance Apply (AttrSym1 l) l = AttrSym2 l l
     instance SuppressUnusedWarnings AttrSym0 where
@@ -268,7 +268,7 @@
         = snd (GHC.Tuple.(,) AttrSym0KindInference GHC.Tuple.())
     data AttrSym0 (l :: TyFun (GHC.Types.[] AChar) (TyFun U Attribute
                                                     -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply AttrSym0 arg)) (KindOf (AttrSym1 arg)) =>
+      = forall arg. KindOf (Apply AttrSym0 arg) ~ KindOf (AttrSym1 arg) =>
         AttrSym0KindInference
     type instance Apply AttrSym0 l = AttrSym1 l
     type SchSym1 (t :: GHC.Types.[] Attribute) = Sch t
@@ -276,7 +276,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) SchSym0KindInference GHC.Tuple.())
     data SchSym0 (l :: TyFun (GHC.Types.[] Attribute) Schema)
-      = forall arg. (GHC.Types.~) (KindOf (Apply SchSym0 arg)) (KindOf (SchSym1 arg)) =>
+      = forall arg. KindOf (Apply SchSym0 arg) ~ KindOf (SchSym1 arg) =>
         SchSym0KindInference
     type instance Apply SchSym0 l = SchSym1 l
     type Let_0123456789Scrutinee_0123456789Sym4 t t t t =
@@ -287,7 +287,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym3 l l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg) =>
         Let_0123456789Scrutinee_0123456789Sym3KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) l = Let_0123456789Scrutinee_0123456789Sym4 l l l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym2 where
@@ -296,7 +296,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>
         Let_0123456789Scrutinee_0123456789Sym2KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where
@@ -305,7 +305,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
         Let_0123456789Scrutinee_0123456789Sym1KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
@@ -314,7 +314,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
         Let_0123456789Scrutinee_0123456789Sym0KindInference
     type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
     type Let_0123456789Scrutinee_0123456789 name name' u attrs =
@@ -328,7 +328,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) LookupSym1KindInference GHC.Tuple.())
     data LookupSym1 (l :: GHC.Types.[] AChar) (l :: TyFun Schema U)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (LookupSym1 l) arg)) (KindOf (LookupSym2 l arg)) =>
+      = forall arg. KindOf (Apply (LookupSym1 l) arg) ~ KindOf (LookupSym2 l arg) =>
         LookupSym1KindInference
     type instance Apply (LookupSym1 l) l = LookupSym2 l l
     instance SuppressUnusedWarnings LookupSym0 where
@@ -336,7 +336,7 @@
         = snd (GHC.Tuple.(,) LookupSym0KindInference GHC.Tuple.())
     data LookupSym0 (l :: TyFun (GHC.Types.[] AChar) (TyFun Schema U
                                                       -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply LookupSym0 arg)) (KindOf (LookupSym1 arg)) =>
+      = forall arg. KindOf (Apply LookupSym0 arg) ~ KindOf (LookupSym1 arg) =>
         LookupSym0KindInference
     type instance Apply LookupSym0 l = LookupSym1 l
     type OccursSym2 (t :: GHC.Types.[] AChar) (t :: Schema) =
@@ -345,7 +345,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) OccursSym1KindInference GHC.Tuple.())
     data OccursSym1 (l :: GHC.Types.[] AChar) (l :: TyFun Schema Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (OccursSym1 l) arg)) (KindOf (OccursSym2 l arg)) =>
+      = forall arg. KindOf (Apply (OccursSym1 l) arg) ~ KindOf (OccursSym2 l arg) =>
         OccursSym1KindInference
     type instance Apply (OccursSym1 l) l = OccursSym2 l l
     instance SuppressUnusedWarnings OccursSym0 where
@@ -353,7 +353,7 @@
         = snd (GHC.Tuple.(,) OccursSym0KindInference GHC.Tuple.())
     data OccursSym0 (l :: TyFun (GHC.Types.[] AChar) (TyFun Schema Bool
                                                       -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply OccursSym0 arg)) (KindOf (OccursSym1 arg)) =>
+      = forall arg. KindOf (Apply OccursSym0 arg) ~ KindOf (OccursSym1 arg) =>
         OccursSym0KindInference
     type instance Apply OccursSym0 l = OccursSym1 l
     type AttrNotInSym2 (t :: Attribute) (t :: Schema) = AttrNotIn t t
@@ -361,14 +361,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) AttrNotInSym1KindInference GHC.Tuple.())
     data AttrNotInSym1 (l :: Attribute) (l :: TyFun Schema Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (AttrNotInSym1 l) arg)) (KindOf (AttrNotInSym2 l arg)) =>
+      = forall arg. KindOf (Apply (AttrNotInSym1 l) arg) ~ KindOf (AttrNotInSym2 l arg) =>
         AttrNotInSym1KindInference
     type instance Apply (AttrNotInSym1 l) l = AttrNotInSym2 l l
     instance SuppressUnusedWarnings AttrNotInSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) AttrNotInSym0KindInference GHC.Tuple.())
     data AttrNotInSym0 (l :: TyFun Attribute (TyFun Schema Bool -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply AttrNotInSym0 arg)) (KindOf (AttrNotInSym1 arg)) =>
+      = forall arg. KindOf (Apply AttrNotInSym0 arg) ~ KindOf (AttrNotInSym1 arg) =>
         AttrNotInSym0KindInference
     type instance Apply AttrNotInSym0 l = AttrNotInSym1 l
     type DisjointSym2 (t :: Schema) (t :: Schema) = Disjoint t t
@@ -376,14 +376,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) DisjointSym1KindInference GHC.Tuple.())
     data DisjointSym1 (l :: Schema) (l :: TyFun Schema Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (DisjointSym1 l) arg)) (KindOf (DisjointSym2 l arg)) =>
+      = forall arg. KindOf (Apply (DisjointSym1 l) arg) ~ KindOf (DisjointSym2 l arg) =>
         DisjointSym1KindInference
     type instance Apply (DisjointSym1 l) l = DisjointSym2 l l
     instance SuppressUnusedWarnings DisjointSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) DisjointSym0KindInference GHC.Tuple.())
     data DisjointSym0 (l :: TyFun Schema (TyFun Schema Bool -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply DisjointSym0 arg)) (KindOf (DisjointSym1 arg)) =>
+      = forall arg. KindOf (Apply DisjointSym0 arg) ~ KindOf (DisjointSym1 arg) =>
         DisjointSym0KindInference
     type instance Apply DisjointSym0 l = DisjointSym1 l
     type AppendSym2 (t :: Schema) (t :: Schema) = Append t t
@@ -391,14 +391,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) AppendSym1KindInference GHC.Tuple.())
     data AppendSym1 (l :: Schema) (l :: TyFun Schema Schema)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (AppendSym1 l) arg)) (KindOf (AppendSym2 l arg)) =>
+      = forall arg. KindOf (Apply (AppendSym1 l) arg) ~ KindOf (AppendSym2 l arg) =>
         AppendSym1KindInference
     type instance Apply (AppendSym1 l) l = AppendSym2 l l
     instance SuppressUnusedWarnings AppendSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) AppendSym0KindInference GHC.Tuple.())
     data AppendSym0 (l :: TyFun Schema (TyFun Schema Schema -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply AppendSym0 arg)) (KindOf (AppendSym1 arg)) =>
+      = forall arg. KindOf (Apply AppendSym0 arg) ~ KindOf (AppendSym1 arg) =>
         AppendSym0KindInference
     type instance Apply AppendSym0 l = AppendSym1 l
     type family Lookup (a :: GHC.Types.[] AChar)
@@ -435,16 +435,15 @@
     sLookup _ (SSch SNil)
       = let
           lambda ::
-            forall wild. ((GHC.Types.~) t wild,
-                          (GHC.Types.~) t (Apply SchSym0 GHC.Types.[])) =>
+            forall wild. (t ~ wild, t ~ Apply SchSym0 GHC.Types.[]) =>
             Sing (Apply (Apply LookupSym0 wild) (Apply SchSym0 GHC.Types.[]))
           lambda = undefined
         in lambda
     sLookup sName (SSch (SCons (SAttr sName' sU) sAttrs))
       = let
           lambda ::
-            forall name name' u attrs. ((GHC.Types.~) t name,
-                                        (GHC.Types.~) t (Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') u)) attrs))) =>
+            forall name name' u attrs. (t ~ name,
+                                        t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') u)) attrs)) =>
             Sing name
             -> Sing name'
                -> Sing u
@@ -476,16 +475,15 @@
     sOccurs _ (SSch SNil)
       = let
           lambda ::
-            forall wild. ((GHC.Types.~) t wild,
-                          (GHC.Types.~) t (Apply SchSym0 GHC.Types.[])) =>
+            forall wild. (t ~ wild, t ~ Apply SchSym0 GHC.Types.[]) =>
             Sing (Apply (Apply OccursSym0 wild) (Apply SchSym0 GHC.Types.[]))
           lambda = SFalse
         in lambda
     sOccurs sName (SSch (SCons (SAttr sName' _) sAttrs))
       = let
           lambda ::
-            forall name name' attrs wild. ((GHC.Types.~) t name,
-                                           (GHC.Types.~) t (Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') wild)) attrs))) =>
+            forall name name' attrs wild. (t ~ name,
+                                           t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') wild)) attrs)) =>
             Sing name
             -> Sing name'
                -> Sing attrs
@@ -503,20 +501,15 @@
     sAttrNotIn _ (SSch SNil)
       = let
           lambda ::
-            forall wild. ((GHC.Types.~) t wild,
-                          (GHC.Types.~) t (Apply SchSym0 GHC.Types.[])) =>
+            forall wild. (t ~ wild, t ~ Apply SchSym0 GHC.Types.[]) =>
             Sing (Apply (Apply AttrNotInSym0 wild) (Apply SchSym0 GHC.Types.[]))
           lambda = STrue
         in lambda
     sAttrNotIn (SAttr sName sU) (SSch (SCons (SAttr sName' _) sT))
       = let
           lambda ::
-            forall name
-                   u
-                   name'
-                   t
-                   wild. ((GHC.Types.~) t (Apply (Apply AttrSym0 name) u),
-                          (GHC.Types.~) t (Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') wild)) t))) =>
+            forall name u name' t wild. (t ~ Apply (Apply AttrSym0 name) u,
+                                         t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') wild)) t)) =>
             Sing name
             -> Sing u
                -> Sing name'
@@ -538,18 +531,15 @@
     sDisjoint (SSch SNil) _
       = let
           lambda ::
-            forall wild. ((GHC.Types.~) t (Apply SchSym0 GHC.Types.[]),
-                          (GHC.Types.~) t wild) =>
+            forall wild. (t ~ Apply SchSym0 GHC.Types.[], t ~ wild) =>
             Sing (Apply (Apply DisjointSym0 (Apply SchSym0 GHC.Types.[])) wild)
           lambda = STrue
         in lambda
     sDisjoint (SSch (SCons sH sT)) sS
       = let
           lambda ::
-            forall h
-                   t
-                   s. ((GHC.Types.~) t (Apply SchSym0 (Apply (Apply (:$) h) t)),
-                       (GHC.Types.~) t s) =>
+            forall h t s. (t ~ Apply SchSym0 (Apply (Apply (:$) h) t),
+                           t ~ s) =>
             Sing h
             -> Sing t
                -> Sing s
@@ -570,8 +560,7 @@
     sAppend (SSch sS1) (SSch sS2)
       = let
           lambda ::
-            forall s1 s2. ((GHC.Types.~) t (Apply SchSym0 s1),
-                           (GHC.Types.~) t (Apply SchSym0 s2)) =>
+            forall s1 s2. (t ~ Apply SchSym0 s1, t ~ Apply SchSym0 s2) =>
             Sing s1
             -> Sing s2
                -> Sing (Apply (Apply AppendSym0 (Apply SchSym0 s1)) (Apply SchSym0 s2))
@@ -582,11 +571,10 @@
                    (applySing (singFun2 (Proxy :: Proxy (:++$)) (%:++)) s1) s2)
         in lambda sS1 sS2
     data instance Sing (z :: U)
-      = (GHC.Types.~) z BOOL => SBOOL |
-        (GHC.Types.~) z STRING => SSTRING |
-        (GHC.Types.~) z NAT => SNAT |
-        forall (n :: U) (n :: Nat). (GHC.Types.~) z (VEC n n) =>
-        SVEC (Sing n) (Sing n)
+      = z ~ BOOL => SBOOL |
+        z ~ STRING => SSTRING |
+        z ~ NAT => SNAT |
+        forall (n :: U) (n :: Nat). z ~ VEC n n => SVEC (Sing n) (Sing n)
     type SU (z :: U) = Sing z
     instance SingKind (KProxy :: KProxy U) where
       type DemoteRep (KProxy :: KProxy U) = U
@@ -693,32 +681,32 @@
             GHC.Tuple.(,) _ (Disproved contra)
               -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
     data instance Sing (z :: AChar)
-      = (GHC.Types.~) z CA => SCA |
-        (GHC.Types.~) z CB => SCB |
-        (GHC.Types.~) z CC => SCC |
-        (GHC.Types.~) z CD => SCD |
-        (GHC.Types.~) z CE => SCE |
-        (GHC.Types.~) z CF => SCF |
-        (GHC.Types.~) z CG => SCG |
-        (GHC.Types.~) z CH => SCH |
-        (GHC.Types.~) z CI => SCI |
-        (GHC.Types.~) z CJ => SCJ |
-        (GHC.Types.~) z CK => SCK |
-        (GHC.Types.~) z CL => SCL |
-        (GHC.Types.~) z CM => SCM |
-        (GHC.Types.~) z CN => SCN |
-        (GHC.Types.~) z CO => SCO |
-        (GHC.Types.~) z CP => SCP |
-        (GHC.Types.~) z CQ => SCQ |
-        (GHC.Types.~) z CR => SCR |
-        (GHC.Types.~) z CS => SCS |
-        (GHC.Types.~) z CT => SCT |
-        (GHC.Types.~) z CU => SCU |
-        (GHC.Types.~) z CV => SCV |
-        (GHC.Types.~) z CW => SCW |
-        (GHC.Types.~) z CX => SCX |
-        (GHC.Types.~) z CY => SCY |
-        (GHC.Types.~) z CZ => SCZ
+      = z ~ CA => SCA |
+        z ~ CB => SCB |
+        z ~ CC => SCC |
+        z ~ CD => SCD |
+        z ~ CE => SCE |
+        z ~ CF => SCF |
+        z ~ CG => SCG |
+        z ~ CH => SCH |
+        z ~ CI => SCI |
+        z ~ CJ => SCJ |
+        z ~ CK => SCK |
+        z ~ CL => SCL |
+        z ~ CM => SCM |
+        z ~ CN => SCN |
+        z ~ CO => SCO |
+        z ~ CP => SCP |
+        z ~ CQ => SCQ |
+        z ~ CR => SCR |
+        z ~ CS => SCS |
+        z ~ CT => SCT |
+        z ~ CU => SCU |
+        z ~ CV => SCV |
+        z ~ CW => SCW |
+        z ~ CX => SCX |
+        z ~ CY => SCY |
+        z ~ CZ => SCZ
     type SAChar (z :: AChar) = Sing z
     instance SingKind (KProxy :: KProxy AChar) where
       type DemoteRep (KProxy :: KProxy AChar) = AChar
@@ -4729,8 +4717,7 @@
                     _ -> error "Empty case reached -- this should be impossible" })
       (%~) SCZ SCZ = Proved Refl
     data instance Sing (z :: Attribute)
-      = forall (n :: GHC.Types.[] AChar)
-               (n :: U). (GHC.Types.~) z (Attr n n) =>
+      = forall (n :: GHC.Types.[] AChar) (n :: U). z ~ Attr n n =>
         SAttr (Sing n) (Sing n)
     type SAttribute (z :: Attribute) = Sing z
     instance SingKind (KProxy :: KProxy Attribute) where
@@ -4744,8 +4731,7 @@
           of {
             GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SAttr c c) }
     data instance Sing (z :: Schema)
-      = forall (n :: GHC.Types.[] Attribute). (GHC.Types.~) z (Sch n) =>
-        SSch (Sing n)
+      = forall (n :: GHC.Types.[] Attribute). z ~ Sch n => SSch (Sing n)
     type SSchema (z :: Schema) = Sing z
     instance SingKind (KProxy :: KProxy Schema) where
       type DemoteRep (KProxy :: KProxy Schema) = Schema
diff --git a/tests/compile-and-dump/GradingClient/Database.hs b/tests/compile-and-dump/GradingClient/Database.hs
--- a/tests/compile-and-dump/GradingClient/Database.hs
+++ b/tests/compile-and-dump/GradingClient/Database.hs
@@ -12,6 +12,7 @@
     GADTs, TypeOperators, RankNTypes, FlexibleContexts, UndecidableInstances,
     FlexibleInstances, ScopedTypeVariables, MultiParamTypeClasses,
     OverlappingInstances, ConstraintKinds, CPP #-}
+{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
 
 -- The OverlappingInstances is needed only to allow the InC and SubsetC classes.
 -- This is simply a convenience so that GHC can infer the necessary proofs of
diff --git a/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template b/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template
--- a/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template
+++ b/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template
@@ -9,12 +9,12 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
     data SuccSym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply SuccSym0 arg)) (KindOf (SuccSym1 arg)) =>
+      = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) =>
         SuccSym0KindInference
     type instance Apply SuccSym0 l = SuccSym1 l
     data instance Sing (z :: Nat)
-      = (GHC.Types.~) z Zero => SZero |
-        forall (n :: Nat). (GHC.Types.~) z (Succ n) => SSucc (Sing n)
+      = z ~ Zero => SZero |
+        forall (n :: Nat). z ~ Succ n => SSucc (Sing n)
     type SNat (z :: Nat) = Sing z
     instance SingKind (KProxy :: KProxy Nat) where
       type DemoteRep (KProxy :: KProxy Nat) = Nat
@@ -65,7 +65,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>
         Let_0123456789Scrutinee_0123456789Sym2KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where
@@ -74,7 +74,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
         Let_0123456789Scrutinee_0123456789Sym1KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
@@ -83,7 +83,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
         Let_0123456789Scrutinee_0123456789Sym0KindInference
     type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
     type Let_0123456789Scrutinee_0123456789 n h t =
@@ -96,14 +96,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) LeqSym1KindInference GHC.Tuple.())
     data LeqSym1 (l :: Nat) (l :: TyFun Nat Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (LeqSym1 l) arg)) (KindOf (LeqSym2 l arg)) =>
+      = forall arg. KindOf (Apply (LeqSym1 l) arg) ~ KindOf (LeqSym2 l arg) =>
         LeqSym1KindInference
     type instance Apply (LeqSym1 l) l = LeqSym2 l l
     instance SuppressUnusedWarnings LeqSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) LeqSym0KindInference GHC.Tuple.())
     data LeqSym0 (l :: TyFun Nat (TyFun Nat Bool -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply LeqSym0 arg)) (KindOf (LeqSym1 arg)) =>
+      = forall arg. KindOf (Apply LeqSym0 arg) ~ KindOf (LeqSym1 arg) =>
         LeqSym0KindInference
     type instance Apply LeqSym0 l = LeqSym1 l
     type InsertSym2 (t :: Nat) (t :: GHC.Types.[] Nat) = Insert t t
@@ -112,7 +112,7 @@
         = snd (GHC.Tuple.(,) InsertSym1KindInference GHC.Tuple.())
     data InsertSym1 (l :: Nat)
                     (l :: TyFun (GHC.Types.[] Nat) (GHC.Types.[] Nat))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (InsertSym1 l) arg)) (KindOf (InsertSym2 l arg)) =>
+      = forall arg. KindOf (Apply (InsertSym1 l) arg) ~ KindOf (InsertSym2 l arg) =>
         InsertSym1KindInference
     type instance Apply (InsertSym1 l) l = InsertSym2 l l
     instance SuppressUnusedWarnings InsertSym0 where
@@ -120,7 +120,7 @@
         = snd (GHC.Tuple.(,) InsertSym0KindInference GHC.Tuple.())
     data InsertSym0 (l :: TyFun Nat (TyFun (GHC.Types.[] Nat) (GHC.Types.[] Nat)
                                      -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply InsertSym0 arg)) (KindOf (InsertSym1 arg)) =>
+      = forall arg. KindOf (Apply InsertSym0 arg) ~ KindOf (InsertSym1 arg) =>
         InsertSym0KindInference
     type instance Apply InsertSym0 l = InsertSym1 l
     type InsertionSortSym1 (t :: GHC.Types.[] Nat) = InsertionSort t
@@ -128,7 +128,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) InsertionSortSym0KindInference GHC.Tuple.())
     data InsertionSortSym0 (l :: TyFun (GHC.Types.[] Nat) (GHC.Types.[] Nat))
-      = forall arg. (GHC.Types.~) (KindOf (Apply InsertionSortSym0 arg)) (KindOf (InsertionSortSym1 arg)) =>
+      = forall arg. KindOf (Apply InsertionSortSym0 arg) ~ KindOf (InsertionSortSym1 arg) =>
         InsertionSortSym0KindInference
     type instance Apply InsertionSortSym0 l = InsertionSortSym1 l
     type family Leq (a :: Nat) (a :: Nat) :: Bool where
@@ -154,23 +154,21 @@
     sLeq SZero _
       = let
           lambda ::
-            forall wild. ((GHC.Types.~) t ZeroSym0, (GHC.Types.~) t wild) =>
+            forall wild. (t ~ ZeroSym0, t ~ wild) =>
             Sing (Apply (Apply LeqSym0 ZeroSym0) wild)
           lambda = STrue
         in lambda
     sLeq (SSucc _) SZero
       = let
           lambda ::
-            forall wild. ((GHC.Types.~) t (Apply SuccSym0 wild),
-                          (GHC.Types.~) t ZeroSym0) =>
+            forall wild. (t ~ Apply SuccSym0 wild, t ~ ZeroSym0) =>
             Sing (Apply (Apply LeqSym0 (Apply SuccSym0 wild)) ZeroSym0)
           lambda = SFalse
         in lambda
     sLeq (SSucc sA) (SSucc sB)
       = let
           lambda ::
-            forall a b. ((GHC.Types.~) t (Apply SuccSym0 a),
-                         (GHC.Types.~) t (Apply SuccSym0 b)) =>
+            forall a b. (t ~ Apply SuccSym0 a, t ~ Apply SuccSym0 b) =>
             Sing a
             -> Sing b
                -> Sing (Apply (Apply LeqSym0 (Apply SuccSym0 a)) (Apply SuccSym0 b))
@@ -181,7 +179,7 @@
     sInsert sN SNil
       = let
           lambda ::
-            forall n. ((GHC.Types.~) t n, (GHC.Types.~) t GHC.Types.[]) =>
+            forall n. (t ~ n, t ~ GHC.Types.[]) =>
             Sing n -> Sing (Apply (Apply InsertSym0 n) GHC.Types.[])
           lambda n
             = applySing
@@ -190,8 +188,7 @@
     sInsert sN (SCons sH sT)
       = let
           lambda ::
-            forall n h t. ((GHC.Types.~) t n,
-                           (GHC.Types.~) t (Apply (Apply (:$) h) t)) =>
+            forall n h t. (t ~ n, t ~ Apply (Apply (:$) h) t) =>
             Sing n
             -> Sing h
                -> Sing t
@@ -226,14 +223,13 @@
     sInsertionSort SNil
       = let
           lambda ::
-            (GHC.Types.~) t GHC.Types.[] =>
-            Sing (Apply InsertionSortSym0 GHC.Types.[])
+            t ~ GHC.Types.[] => Sing (Apply InsertionSortSym0 GHC.Types.[])
           lambda = SNil
         in lambda
     sInsertionSort (SCons sH sT)
       = let
           lambda ::
-            forall h t. (GHC.Types.~) t (Apply (Apply (:$) h) t) =>
+            forall h t. t ~ Apply (Apply (:$) h) t =>
             Sing h
             -> Sing t
                -> Sing (Apply InsertionSortSym0 (Apply (Apply (:$) h) t))
diff --git a/tests/compile-and-dump/Promote/BoundedDeriving.ghc78.template b/tests/compile-and-dump/Promote/BoundedDeriving.ghc78.template
--- a/tests/compile-and-dump/Promote/BoundedDeriving.ghc78.template
+++ b/tests/compile-and-dump/Promote/BoundedDeriving.ghc78.template
@@ -52,7 +52,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
     data Foo3Sym0 (l :: TyFun a (Foo3 a))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply Foo3Sym0 arg)) (Data.Singletons.KindOf (Foo3Sym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply Foo3Sym0 arg) ~ Data.Singletons.KindOf (Foo3Sym1 arg) =>
         Foo3Sym0KindInference
     type instance Apply Foo3Sym0 l = Foo3Sym1 l
     instance PBounded (KProxy :: KProxy (Foo4 k k)) where
@@ -68,13 +68,13 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.())
     data PairSym1 (l :: Bool) (l :: TyFun Bool Pair)
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (PairSym1 l) arg)) (Data.Singletons.KindOf (PairSym2 l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (PairSym1 l) arg) ~ Data.Singletons.KindOf (PairSym2 l arg) =>
         PairSym1KindInference
     type instance Apply (PairSym1 l) l = PairSym2 l l
     instance SuppressUnusedWarnings PairSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.())
     data PairSym0 (l :: TyFun Bool (TyFun Bool Pair -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply PairSym0 arg)) (Data.Singletons.KindOf (PairSym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply PairSym0 arg) ~ Data.Singletons.KindOf (PairSym1 arg) =>
         PairSym0KindInference
     type instance Apply PairSym0 l = PairSym1 l
diff --git a/tests/compile-and-dump/Promote/Classes.ghc78.template b/tests/compile-and-dump/Promote/Classes.ghc78.template
--- a/tests/compile-and-dump/Promote/Classes.ghc78.template
+++ b/tests/compile-and-dump/Promote/Classes.ghc78.template
@@ -49,14 +49,14 @@
       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)) =>
+      = forall arg. 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)) =>
+      = forall arg. KindOf (Apply FooCompareSym0 arg) ~ KindOf (FooCompareSym1 arg) =>
         FooCompareSym0KindInference
     type instance Apply FooCompareSym0 l = FooCompareSym1 l
     type ConstSym2 (t :: a) (t :: b) = Const t t
@@ -64,14 +64,14 @@
       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)) =>
+      = forall arg. 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)) =>
+      = forall arg. KindOf (Apply ConstSym0 arg) ~ KindOf (ConstSym1 arg) =>
         ConstSym0KindInference
     type instance Apply ConstSym0 l = ConstSym1 l
     type family FooCompare (a :: Foo) (a :: Foo) :: Ordering where
@@ -85,14 +85,14 @@
       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)) =>
+      = forall arg. 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)) =>
+      = forall arg. KindOf (Apply MycompareSym0 arg) ~ KindOf (MycompareSym1 arg) =>
         MycompareSym0KindInference
     type instance Apply MycompareSym0 l = MycompareSym1 l
     type (:<=>$$$) (t :: a) (t :: a) = (:<=>) t t
@@ -100,17 +100,17 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) (:<=>$$###) GHC.Tuple.())
     data (:<=>$$) (l :: a) (l :: TyFun a Ordering)
-      = forall arg. (GHC.Types.~) (KindOf (Apply ((:<=>$$) l) arg)) (KindOf ((:<=>$$$) l arg)) =>
+      = forall arg. 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)) =>
+      = forall arg. KindOf (Apply (:<=>$) arg) ~ KindOf ((:<=>$$) arg) =>
         (:<=>$###)
     type instance Apply (:<=>$) l = (:<=>$$) l
-    class (GHC.Types.~) kproxy KProxy => PMyOrd (kproxy :: KProxy a) where
+    class 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)
@@ -153,6 +153,6 @@
       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)) =>
+      = forall arg. KindOf (Apply Succ'Sym0 arg) ~ KindOf (Succ'Sym1 arg) =>
         Succ'Sym0KindInference
     type instance Apply Succ'Sym0 l = Succ'Sym1 l
diff --git a/tests/compile-and-dump/Promote/Constructors.ghc78.template b/tests/compile-and-dump/Promote/Constructors.ghc78.template
--- a/tests/compile-and-dump/Promote/Constructors.ghc78.template
+++ b/tests/compile-and-dump/Promote/Constructors.ghc78.template
@@ -12,14 +12,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
     data (:+$$) (l :: Foo) (l :: TyFun Foo Foo)
-      = forall arg. (GHC.Types.~) (KindOf (Apply ((:+$$) l) arg)) (KindOf ((:+$$$) l arg)) =>
+      = forall arg. 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 Foo (TyFun Foo Foo -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (:+$) arg)) (KindOf ((:+$$) arg)) =>
+      = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) =>
         (:+$###)
     type instance Apply (:+$) l = (:+$$) l
     type BarSym5 (t :: Bar)
@@ -36,7 +36,7 @@
                  (l :: Bar)
                  (l :: Bar)
                  (l :: TyFun Foo Bar)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (BarSym4 l l l l) arg)) (KindOf (BarSym5 l l l l arg)) =>
+      = forall arg. KindOf (Apply (BarSym4 l l l l) arg) ~ KindOf (BarSym5 l l l l arg) =>
         BarSym4KindInference
     type instance Apply (BarSym4 l l l l) l = BarSym5 l l l l l
     instance SuppressUnusedWarnings BarSym3 where
@@ -46,7 +46,7 @@
                  (l :: Bar)
                  (l :: Bar)
                  (l :: TyFun Bar (TyFun Foo Bar -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (BarSym3 l l l) arg)) (KindOf (BarSym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (BarSym3 l l l) arg) ~ KindOf (BarSym4 l l l arg) =>
         BarSym3KindInference
     type instance Apply (BarSym3 l l l) l = BarSym4 l l l l
     instance SuppressUnusedWarnings BarSym2 where
@@ -55,7 +55,7 @@
     data BarSym2 (l :: Bar)
                  (l :: Bar)
                  (l :: TyFun Bar (TyFun Bar (TyFun Foo Bar -> *) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (BarSym2 l l) arg)) (KindOf (BarSym3 l l arg)) =>
+      = forall arg. KindOf (Apply (BarSym2 l l) arg) ~ KindOf (BarSym3 l l arg) =>
         BarSym2KindInference
     type instance Apply (BarSym2 l l) l = BarSym3 l l l
     instance SuppressUnusedWarnings BarSym1 where
@@ -64,7 +64,7 @@
     data BarSym1 (l :: Bar)
                  (l :: TyFun Bar (TyFun Bar (TyFun Bar (TyFun Foo Bar -> *) -> *)
                                   -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (BarSym1 l) arg)) (KindOf (BarSym2 l arg)) =>
+      = forall arg. KindOf (Apply (BarSym1 l) arg) ~ KindOf (BarSym2 l arg) =>
         BarSym1KindInference
     type instance Apply (BarSym1 l) l = BarSym2 l l
     instance SuppressUnusedWarnings BarSym0 where
@@ -75,6 +75,6 @@
                                                         -> *)
                                              -> *)
                                   -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply BarSym0 arg)) (KindOf (BarSym1 arg)) =>
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
         BarSym0KindInference
     type instance Apply BarSym0 l = BarSym1 l
diff --git a/tests/compile-and-dump/Promote/GenDefunSymbols.ghc78.template b/tests/compile-and-dump/Promote/GenDefunSymbols.ghc78.template
--- a/tests/compile-and-dump/Promote/GenDefunSymbols.ghc78.template
+++ b/tests/compile-and-dump/Promote/GenDefunSymbols.ghc78.template
@@ -9,7 +9,7 @@
         = snd (GHC.Tuple.(,) LiftMaybeSym1KindInference GHC.Tuple.())
     data LiftMaybeSym1 (l :: TyFun a b -> *)
                        (l :: TyFun (Maybe a) (Maybe b))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (LiftMaybeSym1 l) arg)) (Data.Singletons.KindOf (LiftMaybeSym2 l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (LiftMaybeSym1 l) arg) ~ Data.Singletons.KindOf (LiftMaybeSym2 l arg) =>
         LiftMaybeSym1KindInference
     type instance Apply (LiftMaybeSym1 l) l = LiftMaybeSym2 l l
     instance SuppressUnusedWarnings LiftMaybeSym0 where
@@ -17,7 +17,7 @@
         = snd (GHC.Tuple.(,) LiftMaybeSym0KindInference GHC.Tuple.())
     data LiftMaybeSym0 (l :: TyFun (TyFun a b
                                     -> *) (TyFun (Maybe a) (Maybe b) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply LiftMaybeSym0 arg)) (Data.Singletons.KindOf (LiftMaybeSym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply LiftMaybeSym0 arg) ~ Data.Singletons.KindOf (LiftMaybeSym1 arg) =>
         LiftMaybeSym0KindInference
     type instance Apply LiftMaybeSym0 l = LiftMaybeSym1 l
     type ZeroSym0 = Zero
@@ -26,7 +26,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
     data SuccSym0 (l :: TyFun NatT NatT)
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply SuccSym0 arg)) (Data.Singletons.KindOf (SuccSym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply SuccSym0 arg) ~ Data.Singletons.KindOf (SuccSym1 arg) =>
         SuccSym0KindInference
     type instance Apply SuccSym0 l = SuccSym1 l
     type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t
@@ -34,13 +34,13 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
     data (:+$$) (l :: Nat) l
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply ((:+$$) l) arg)) (Data.Singletons.KindOf ((:+$$$) l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply ((:+$$) l) arg) ~ Data.Singletons.KindOf ((:+$$$) l arg) =>
         (:+$$###)
     type instance Apply ((:+$$) l) l = (:+$$$) l l
     instance SuppressUnusedWarnings (:+$) where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.())
     data (:+$) l
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (:+$) arg)) (Data.Singletons.KindOf ((:+$$) arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (:+$) arg) ~ Data.Singletons.KindOf ((:+$$) arg) =>
         (:+$###)
     type instance Apply (:+$) l = (:+$$) l
diff --git a/tests/compile-and-dump/Promote/Newtypes.ghc78.template b/tests/compile-and-dump/Promote/Newtypes.ghc78.template
--- a/tests/compile-and-dump/Promote/Newtypes.ghc78.template
+++ b/tests/compile-and-dump/Promote/Newtypes.ghc78.template
@@ -15,7 +15,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) UnBarSym0KindInference GHC.Tuple.())
     data UnBarSym0 (l :: TyFun Bar Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply UnBarSym0 arg)) (KindOf (UnBarSym1 arg)) =>
+      = forall arg. KindOf (Apply UnBarSym0 arg) ~ KindOf (UnBarSym1 arg) =>
         UnBarSym0KindInference
     type instance Apply UnBarSym0 l = UnBarSym1 l
     type family UnBar (a :: Bar) :: Nat where
@@ -30,7 +30,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
     data FooSym0 (l :: TyFun Nat Foo)
-      = forall arg. (GHC.Types.~) (KindOf (Apply FooSym0 arg)) (KindOf (FooSym1 arg)) =>
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
         FooSym0KindInference
     type instance Apply FooSym0 l = FooSym1 l
     type BarSym1 (t :: Nat) = Bar t
@@ -38,6 +38,6 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
     data BarSym0 (l :: TyFun Nat Bar)
-      = forall arg. (GHC.Types.~) (KindOf (Apply BarSym0 arg)) (KindOf (BarSym1 arg)) =>
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
         BarSym0KindInference
     type instance Apply BarSym0 l = BarSym1 l
diff --git a/tests/compile-and-dump/Promote/OrdDeriving.ghc78.template b/tests/compile-and-dump/Promote/OrdDeriving.ghc78.template
--- a/tests/compile-and-dump/Promote/OrdDeriving.ghc78.template
+++ b/tests/compile-and-dump/Promote/OrdDeriving.ghc78.template
@@ -41,7 +41,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
     data SuccSym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply SuccSym0 arg)) (Data.Singletons.KindOf (SuccSym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply SuccSym0 arg) ~ Data.Singletons.KindOf (SuccSym1 arg) =>
         SuccSym0KindInference
     type instance Apply SuccSym0 l = SuccSym1 l
     type family Equals_0123456789 (a :: Foo k k k k)
@@ -97,7 +97,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) ASym3KindInference GHC.Tuple.())
     data ASym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (ASym3 l l l) arg)) (Data.Singletons.KindOf (ASym4 l l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (ASym3 l l l) arg) ~ Data.Singletons.KindOf (ASym4 l l l arg) =>
         ASym3KindInference
     type instance Apply (ASym3 l l l) l = ASym4 l l l l
     instance SuppressUnusedWarnings ASym2 where
@@ -106,7 +106,7 @@
     data ASym2 (l :: a)
                (l :: b)
                (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (ASym2 l l) arg)) (Data.Singletons.KindOf (ASym3 l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (ASym2 l l) arg) ~ Data.Singletons.KindOf (ASym3 l l arg) =>
         ASym2KindInference
     type instance Apply (ASym2 l l) l = ASym3 l l l
     instance SuppressUnusedWarnings ASym1 where
@@ -114,7 +114,7 @@
         = snd (GHC.Tuple.(,) ASym1KindInference GHC.Tuple.())
     data ASym1 (l :: a)
                (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (ASym1 l) arg)) (Data.Singletons.KindOf (ASym2 l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (ASym1 l) arg) ~ Data.Singletons.KindOf (ASym2 l arg) =>
         ASym1KindInference
     type instance Apply (ASym1 l) l = ASym2 l l
     instance SuppressUnusedWarnings ASym0 where
@@ -124,7 +124,7 @@
                                                 -> *)
                                        -> *)
                               -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply ASym0 arg)) (Data.Singletons.KindOf (ASym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply ASym0 arg) ~ Data.Singletons.KindOf (ASym1 arg) =>
         ASym0KindInference
     type instance Apply ASym0 l = ASym1 l
     type BSym4 (t :: a) (t :: b) (t :: c) (t :: d) = B t t t t
@@ -132,7 +132,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) BSym3KindInference GHC.Tuple.())
     data BSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (BSym3 l l l) arg)) (Data.Singletons.KindOf (BSym4 l l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (BSym3 l l l) arg) ~ Data.Singletons.KindOf (BSym4 l l l arg) =>
         BSym3KindInference
     type instance Apply (BSym3 l l l) l = BSym4 l l l l
     instance SuppressUnusedWarnings BSym2 where
@@ -141,7 +141,7 @@
     data BSym2 (l :: a)
                (l :: b)
                (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (BSym2 l l) arg)) (Data.Singletons.KindOf (BSym3 l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (BSym2 l l) arg) ~ Data.Singletons.KindOf (BSym3 l l arg) =>
         BSym2KindInference
     type instance Apply (BSym2 l l) l = BSym3 l l l
     instance SuppressUnusedWarnings BSym1 where
@@ -149,7 +149,7 @@
         = snd (GHC.Tuple.(,) BSym1KindInference GHC.Tuple.())
     data BSym1 (l :: a)
                (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (BSym1 l) arg)) (Data.Singletons.KindOf (BSym2 l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (BSym1 l) arg) ~ Data.Singletons.KindOf (BSym2 l arg) =>
         BSym1KindInference
     type instance Apply (BSym1 l) l = BSym2 l l
     instance SuppressUnusedWarnings BSym0 where
@@ -159,7 +159,7 @@
                                                 -> *)
                                        -> *)
                               -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply BSym0 arg)) (Data.Singletons.KindOf (BSym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply BSym0 arg) ~ Data.Singletons.KindOf (BSym1 arg) =>
         BSym0KindInference
     type instance Apply BSym0 l = BSym1 l
     type CSym4 (t :: a) (t :: b) (t :: c) (t :: d) = C t t t t
@@ -167,7 +167,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) CSym3KindInference GHC.Tuple.())
     data CSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (CSym3 l l l) arg)) (Data.Singletons.KindOf (CSym4 l l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (CSym3 l l l) arg) ~ Data.Singletons.KindOf (CSym4 l l l arg) =>
         CSym3KindInference
     type instance Apply (CSym3 l l l) l = CSym4 l l l l
     instance SuppressUnusedWarnings CSym2 where
@@ -176,7 +176,7 @@
     data CSym2 (l :: a)
                (l :: b)
                (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (CSym2 l l) arg)) (Data.Singletons.KindOf (CSym3 l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (CSym2 l l) arg) ~ Data.Singletons.KindOf (CSym3 l l arg) =>
         CSym2KindInference
     type instance Apply (CSym2 l l) l = CSym3 l l l
     instance SuppressUnusedWarnings CSym1 where
@@ -184,7 +184,7 @@
         = snd (GHC.Tuple.(,) CSym1KindInference GHC.Tuple.())
     data CSym1 (l :: a)
                (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (CSym1 l) arg)) (Data.Singletons.KindOf (CSym2 l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (CSym1 l) arg) ~ Data.Singletons.KindOf (CSym2 l arg) =>
         CSym1KindInference
     type instance Apply (CSym1 l) l = CSym2 l l
     instance SuppressUnusedWarnings CSym0 where
@@ -194,7 +194,7 @@
                                                 -> *)
                                        -> *)
                               -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply CSym0 arg)) (Data.Singletons.KindOf (CSym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply CSym0 arg) ~ Data.Singletons.KindOf (CSym1 arg) =>
         CSym0KindInference
     type instance Apply CSym0 l = CSym1 l
     type DSym4 (t :: a) (t :: b) (t :: c) (t :: d) = D t t t t
@@ -202,7 +202,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) DSym3KindInference GHC.Tuple.())
     data DSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (DSym3 l l l) arg)) (Data.Singletons.KindOf (DSym4 l l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (DSym3 l l l) arg) ~ Data.Singletons.KindOf (DSym4 l l l arg) =>
         DSym3KindInference
     type instance Apply (DSym3 l l l) l = DSym4 l l l l
     instance SuppressUnusedWarnings DSym2 where
@@ -211,7 +211,7 @@
     data DSym2 (l :: a)
                (l :: b)
                (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (DSym2 l l) arg)) (Data.Singletons.KindOf (DSym3 l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (DSym2 l l) arg) ~ Data.Singletons.KindOf (DSym3 l l arg) =>
         DSym2KindInference
     type instance Apply (DSym2 l l) l = DSym3 l l l
     instance SuppressUnusedWarnings DSym1 where
@@ -219,7 +219,7 @@
         = snd (GHC.Tuple.(,) DSym1KindInference GHC.Tuple.())
     data DSym1 (l :: a)
                (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (DSym1 l) arg)) (Data.Singletons.KindOf (DSym2 l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (DSym1 l) arg) ~ Data.Singletons.KindOf (DSym2 l arg) =>
         DSym1KindInference
     type instance Apply (DSym1 l) l = DSym2 l l
     instance SuppressUnusedWarnings DSym0 where
@@ -229,7 +229,7 @@
                                                 -> *)
                                        -> *)
                               -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply DSym0 arg)) (Data.Singletons.KindOf (DSym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply DSym0 arg) ~ Data.Singletons.KindOf (DSym1 arg) =>
         DSym0KindInference
     type instance Apply DSym0 l = DSym1 l
     type ESym4 (t :: a) (t :: b) (t :: c) (t :: d) = E t t t t
@@ -237,7 +237,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) ESym3KindInference GHC.Tuple.())
     data ESym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (ESym3 l l l) arg)) (Data.Singletons.KindOf (ESym4 l l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (ESym3 l l l) arg) ~ Data.Singletons.KindOf (ESym4 l l l arg) =>
         ESym3KindInference
     type instance Apply (ESym3 l l l) l = ESym4 l l l l
     instance SuppressUnusedWarnings ESym2 where
@@ -246,7 +246,7 @@
     data ESym2 (l :: a)
                (l :: b)
                (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (ESym2 l l) arg)) (Data.Singletons.KindOf (ESym3 l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (ESym2 l l) arg) ~ Data.Singletons.KindOf (ESym3 l l arg) =>
         ESym2KindInference
     type instance Apply (ESym2 l l) l = ESym3 l l l
     instance SuppressUnusedWarnings ESym1 where
@@ -254,7 +254,7 @@
         = snd (GHC.Tuple.(,) ESym1KindInference GHC.Tuple.())
     data ESym1 (l :: a)
                (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (ESym1 l) arg)) (Data.Singletons.KindOf (ESym2 l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (ESym1 l) arg) ~ Data.Singletons.KindOf (ESym2 l arg) =>
         ESym1KindInference
     type instance Apply (ESym1 l) l = ESym2 l l
     instance SuppressUnusedWarnings ESym0 where
@@ -264,7 +264,7 @@
                                                 -> *)
                                        -> *)
                               -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply ESym0 arg)) (Data.Singletons.KindOf (ESym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply ESym0 arg) ~ Data.Singletons.KindOf (ESym1 arg) =>
         ESym0KindInference
     type instance Apply ESym0 l = ESym1 l
     type FSym4 (t :: a) (t :: b) (t :: c) (t :: d) = F t t t t
@@ -272,7 +272,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) FSym3KindInference GHC.Tuple.())
     data FSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (FSym3 l l l) arg)) (Data.Singletons.KindOf (FSym4 l l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (FSym3 l l l) arg) ~ Data.Singletons.KindOf (FSym4 l l l arg) =>
         FSym3KindInference
     type instance Apply (FSym3 l l l) l = FSym4 l l l l
     instance SuppressUnusedWarnings FSym2 where
@@ -281,7 +281,7 @@
     data FSym2 (l :: a)
                (l :: b)
                (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (FSym2 l l) arg)) (Data.Singletons.KindOf (FSym3 l l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (FSym2 l l) arg) ~ Data.Singletons.KindOf (FSym3 l l arg) =>
         FSym2KindInference
     type instance Apply (FSym2 l l) l = FSym3 l l l
     instance SuppressUnusedWarnings FSym1 where
@@ -289,7 +289,7 @@
         = snd (GHC.Tuple.(,) FSym1KindInference GHC.Tuple.())
     data FSym1 (l :: a)
                (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply (FSym1 l) arg)) (Data.Singletons.KindOf (FSym2 l arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply (FSym1 l) arg) ~ Data.Singletons.KindOf (FSym2 l arg) =>
         FSym1KindInference
     type instance Apply (FSym1 l) l = FSym2 l l
     instance SuppressUnusedWarnings FSym0 where
@@ -299,6 +299,6 @@
                                                 -> *)
                                        -> *)
                               -> *))
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply FSym0 arg)) (Data.Singletons.KindOf (FSym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply FSym0 arg) ~ Data.Singletons.KindOf (FSym1 arg) =>
         FSym0KindInference
     type instance Apply FSym0 l = FSym1 l
diff --git a/tests/compile-and-dump/Promote/Prelude.ghc78.template b/tests/compile-and-dump/Promote/Prelude.ghc78.template
--- a/tests/compile-and-dump/Promote/Prelude.ghc78.template
+++ b/tests/compile-and-dump/Promote/Prelude.ghc78.template
@@ -10,7 +10,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) OddSym0KindInference GHC.Tuple.())
     data OddSym0 (l :: TyFun Nat Bool)
-      = forall arg. (GHC.Types.~) (Data.Singletons.KindOf (Apply OddSym0 arg)) (Data.Singletons.KindOf (OddSym1 arg)) =>
+      = forall arg. Data.Singletons.KindOf (Apply OddSym0 arg) ~ Data.Singletons.KindOf (OddSym1 arg) =>
         OddSym0KindInference
     type instance Apply OddSym0 l = OddSym1 l
     type family Odd (a :: Nat) :: Bool where
diff --git a/tests/compile-and-dump/Promote/TopLevelPatterns.ghc78.template b/tests/compile-and-dump/Promote/TopLevelPatterns.ghc78.template
--- a/tests/compile-and-dump/Promote/TopLevelPatterns.ghc78.template
+++ b/tests/compile-and-dump/Promote/TopLevelPatterns.ghc78.template
@@ -58,7 +58,7 @@
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) NotSym0KindInference GHC.Tuple.())
     data NotSym0 (l :: TyFun Bool Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply NotSym0 arg)) (KindOf (NotSym1 arg)) =>
+      = forall arg. KindOf (Apply NotSym0 arg) ~ KindOf (NotSym1 arg) =>
         NotSym0KindInference
     type instance Apply NotSym0 l = NotSym1 l
     type IdSym1 (t :: a) = Id t
@@ -66,7 +66,7 @@
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) IdSym0KindInference GHC.Tuple.())
     data IdSym0 (l :: TyFun a a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply IdSym0 arg)) (KindOf (IdSym1 arg)) =>
+      = forall arg. KindOf (Apply IdSym0 arg) ~ KindOf (IdSym1 arg) =>
         IdSym0KindInference
     type instance Apply IdSym0 l = IdSym1 l
     type FSym1 (t :: Bool) = F t
@@ -74,7 +74,7 @@
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) FSym0KindInference GHC.Tuple.())
     data FSym0 (l :: TyFun Bool Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply FSym0 arg)) (KindOf (FSym1 arg)) =>
+      = forall arg. KindOf (Apply FSym0 arg) ~ KindOf (FSym1 arg) =>
         FSym0KindInference
     type instance Apply FSym0 l = FSym1 l
     type GSym1 (t :: Bool) = G t
@@ -82,7 +82,7 @@
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) GSym0KindInference GHC.Tuple.())
     data GSym0 (l :: TyFun Bool Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply GSym0 arg)) (KindOf (GSym1 arg)) =>
+      = forall arg. KindOf (Apply GSym0 arg) ~ KindOf (GSym1 arg) =>
         GSym0KindInference
     type instance Apply GSym0 l = GSym1 l
     type HSym1 (t :: Bool) = H t
@@ -90,7 +90,7 @@
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) HSym0KindInference GHC.Tuple.())
     data HSym0 (l :: TyFun Bool Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply HSym0 arg)) (KindOf (HSym1 arg)) =>
+      = forall arg. KindOf (Apply HSym0 arg) ~ KindOf (HSym1 arg) =>
         HSym0KindInference
     type instance Apply HSym0 l = HSym1 l
     type ISym1 (t :: Bool) = I t
@@ -98,7 +98,7 @@
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) ISym0KindInference GHC.Tuple.())
     data ISym0 (l :: TyFun Bool Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply ISym0 arg)) (KindOf (ISym1 arg)) =>
+      = forall arg. KindOf (Apply ISym0 arg) ~ KindOf (ISym1 arg) =>
         ISym0KindInference
     type instance Apply ISym0 l = ISym1 l
     type JSym0 = J
@@ -140,13 +140,13 @@
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) BarSym1KindInference GHC.Tuple.())
     data BarSym1 (l :: Bool) (l :: TyFun Bool Foo)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (BarSym1 l) arg)) (KindOf (BarSym2 l arg)) =>
+      = forall arg. KindOf (Apply (BarSym1 l) arg) ~ KindOf (BarSym2 l arg) =>
         BarSym1KindInference
     type instance Apply (BarSym1 l) l = BarSym2 l l
     instance SuppressUnusedWarnings BarSym0 where
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
     data BarSym0 (l :: TyFun Bool (TyFun Bool Foo -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply BarSym0 arg)) (KindOf (BarSym1 arg)) =>
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
         BarSym0KindInference
     type instance Apply BarSym0 l = BarSym1 l
diff --git a/tests/compile-and-dump/Singletons/AsPattern.ghc78.template b/tests/compile-and-dump/Singletons/AsPattern.ghc78.template
--- a/tests/compile-and-dump/Singletons/AsPattern.ghc78.template
+++ b/tests/compile-and-dump/Singletons/AsPattern.ghc78.template
@@ -15,7 +15,7 @@
           foo p@[] = p
           foo p@[_] = p
           foo p@(_ : _) = p
-
+          
           data Baz = Baz Nat Nat Nat |]
   ======>
     Singletons/AsPattern.hs:(0,0)-(0,0)
@@ -40,21 +40,21 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) BazSym2KindInference GHC.Tuple.())
     data BazSym2 (l :: Nat) (l :: Nat) (l :: TyFun Nat Baz)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (BazSym2 l l) arg)) (KindOf (BazSym3 l l arg)) =>
+      = forall arg. KindOf (Apply (BazSym2 l l) arg) ~ KindOf (BazSym3 l l arg) =>
         BazSym2KindInference
     type instance Apply (BazSym2 l l) l = BazSym3 l l l
     instance SuppressUnusedWarnings BazSym1 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) BazSym1KindInference GHC.Tuple.())
     data BazSym1 (l :: Nat) (l :: TyFun Nat (TyFun Nat Baz -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (BazSym1 l) arg)) (KindOf (BazSym2 l arg)) =>
+      = forall arg. KindOf (Apply (BazSym1 l) arg) ~ KindOf (BazSym2 l arg) =>
         BazSym1KindInference
     type instance Apply (BazSym1 l) l = BazSym2 l l
     instance SuppressUnusedWarnings BazSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) BazSym0KindInference GHC.Tuple.())
     data BazSym0 (l :: TyFun Nat (TyFun Nat (TyFun Nat Baz -> *) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply BazSym0 arg)) (KindOf (BazSym1 arg)) =>
+      = forall arg. KindOf (Apply BazSym0 arg) ~ KindOf (BazSym1 arg) =>
         BazSym0KindInference
     type instance Apply BazSym0 l = BazSym1 l
     type Let_0123456789PSym0 = Let_0123456789P
@@ -64,7 +64,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789PSym0KindInference GHC.Tuple.())
     data Let_0123456789PSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789PSym0 arg)) (KindOf (Let_0123456789PSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>
         Let_0123456789PSym0KindInference
     type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l
     type Let_0123456789P wild_0123456789 =
@@ -74,14 +74,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789PSym1KindInference GHC.Tuple.())
     data Let_0123456789PSym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789PSym1 l) arg)) (KindOf (Let_0123456789PSym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789PSym1 l) arg) ~ KindOf (Let_0123456789PSym2 l arg) =>
         Let_0123456789PSym1KindInference
     type instance Apply (Let_0123456789PSym1 l) l = Let_0123456789PSym2 l l
     instance SuppressUnusedWarnings Let_0123456789PSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789PSym0KindInference GHC.Tuple.())
     data Let_0123456789PSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789PSym0 arg)) (KindOf (Let_0123456789PSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>
         Let_0123456789PSym0KindInference
     type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l
     type Let_0123456789P wild_0123456789 wild_0123456789 =
@@ -91,14 +91,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789PSym1KindInference GHC.Tuple.())
     data Let_0123456789PSym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789PSym1 l) arg)) (KindOf (Let_0123456789PSym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789PSym1 l) arg) ~ KindOf (Let_0123456789PSym2 l arg) =>
         Let_0123456789PSym1KindInference
     type instance Apply (Let_0123456789PSym1 l) l = Let_0123456789PSym2 l l
     instance SuppressUnusedWarnings Let_0123456789PSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789PSym0KindInference GHC.Tuple.())
     data Let_0123456789PSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789PSym0 arg)) (KindOf (Let_0123456789PSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>
         Let_0123456789PSym0KindInference
     type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l
     type Let_0123456789P wild_0123456789 wild_0123456789 =
@@ -110,21 +110,21 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789PSym2KindInference GHC.Tuple.())
     data Let_0123456789PSym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789PSym2 l l) arg)) (KindOf (Let_0123456789PSym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789PSym2 l l) arg) ~ KindOf (Let_0123456789PSym3 l l arg) =>
         Let_0123456789PSym2KindInference
     type instance Apply (Let_0123456789PSym2 l l) l = Let_0123456789PSym3 l l l
     instance SuppressUnusedWarnings Let_0123456789PSym1 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789PSym1KindInference GHC.Tuple.())
     data Let_0123456789PSym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789PSym1 l) arg)) (KindOf (Let_0123456789PSym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789PSym1 l) arg) ~ KindOf (Let_0123456789PSym2 l arg) =>
         Let_0123456789PSym1KindInference
     type instance Apply (Let_0123456789PSym1 l) l = Let_0123456789PSym2 l l
     instance SuppressUnusedWarnings Let_0123456789PSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789PSym0KindInference GHC.Tuple.())
     data Let_0123456789PSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789PSym0 arg)) (KindOf (Let_0123456789PSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>
         Let_0123456789PSym0KindInference
     type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l
     type Let_0123456789P wild_0123456789
@@ -136,7 +136,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789XSym0KindInference GHC.Tuple.())
     data Let_0123456789XSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789XSym0 arg)) (KindOf (Let_0123456789XSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789XSym0 arg) ~ KindOf (Let_0123456789XSym1 arg) =>
         Let_0123456789XSym0KindInference
     type instance Apply Let_0123456789XSym0 l = Let_0123456789XSym1 l
     type Let_0123456789X wild_0123456789 =
@@ -148,7 +148,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
     data FooSym0 (l :: TyFun (GHC.Types.[] Nat) (GHC.Types.[] Nat))
-      = forall arg. (GHC.Types.~) (KindOf (Apply FooSym0 arg)) (KindOf (FooSym1 arg)) =>
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
         FooSym0KindInference
     type instance Apply FooSym0 l = FooSym1 l
     type TupSym1 (t :: GHC.Tuple.(,) Nat Nat) = Tup t
@@ -156,7 +156,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) TupSym0KindInference GHC.Tuple.())
     data TupSym0 (l :: TyFun (GHC.Tuple.(,) Nat Nat) (GHC.Tuple.(,) Nat Nat))
-      = forall arg. (GHC.Types.~) (KindOf (Apply TupSym0 arg)) (KindOf (TupSym1 arg)) =>
+      = forall arg. KindOf (Apply TupSym0 arg) ~ KindOf (TupSym1 arg) =>
         TupSym0KindInference
     type instance Apply TupSym0 l = TupSym1 l
     type Baz_Sym1 (t :: Maybe Baz) = Baz_ t
@@ -164,7 +164,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Baz_Sym0KindInference GHC.Tuple.())
     data Baz_Sym0 (l :: TyFun (Maybe Baz) (Maybe Baz))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Baz_Sym0 arg)) (KindOf (Baz_Sym1 arg)) =>
+      = forall arg. KindOf (Apply Baz_Sym0 arg) ~ KindOf (Baz_Sym1 arg) =>
         Baz_Sym0KindInference
     type instance Apply Baz_Sym0 l = Baz_Sym1 l
     type BarSym1 (t :: Maybe Nat) = Bar t
@@ -172,7 +172,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
     data BarSym0 (l :: TyFun (Maybe Nat) (Maybe Nat))
-      = forall arg. (GHC.Types.~) (KindOf (Apply BarSym0 arg)) (KindOf (BarSym1 arg)) =>
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
         BarSym0KindInference
     type instance Apply BarSym0 l = BarSym1 l
     type MaybePlusSym1 (t :: Maybe Nat) = MaybePlus t
@@ -180,7 +180,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) MaybePlusSym0KindInference GHC.Tuple.())
     data MaybePlusSym0 (l :: TyFun (Maybe Nat) (Maybe Nat))
-      = forall arg. (GHC.Types.~) (KindOf (Apply MaybePlusSym0 arg)) (KindOf (MaybePlusSym1 arg)) =>
+      = forall arg. KindOf (Apply MaybePlusSym0 arg) ~ KindOf (MaybePlusSym1 arg) =>
         MaybePlusSym0KindInference
     type instance Apply MaybePlusSym0 l = MaybePlusSym1 l
     type family Foo (a :: GHC.Types.[] Nat) :: GHC.Types.[] Nat where
@@ -209,8 +209,7 @@
       forall (t :: Maybe Nat). Sing t -> Sing (Apply MaybePlusSym0 t)
     sFoo SNil
       = let
-          lambda ::
-            (GHC.Types.~) t GHC.Types.[] => Sing (Apply FooSym0 GHC.Types.[])
+          lambda :: t ~ GHC.Types.[] => Sing (Apply FooSym0 GHC.Types.[])
           lambda
             = let
                 sP :: Sing Let_0123456789PSym0
@@ -220,7 +219,7 @@
     sFoo (SCons sWild_0123456789 SNil)
       = let
           lambda ::
-            forall wild_0123456789. (GHC.Types.~) t (Apply (Apply (:$) wild_0123456789) GHC.Types.[]) =>
+            forall wild_0123456789. t ~ Apply (Apply (:$) wild_0123456789) GHC.Types.[] =>
             Sing wild_0123456789
             -> Sing (Apply FooSym0 (Apply (Apply (:$) wild_0123456789) GHC.Types.[]))
           lambda wild_0123456789
@@ -236,7 +235,7 @@
       = let
           lambda ::
             forall wild_0123456789
-                   wild_0123456789. (GHC.Types.~) t (Apply (Apply (:$) wild_0123456789) wild_0123456789) =>
+                   wild_0123456789. t ~ Apply (Apply (:$) wild_0123456789) wild_0123456789 =>
             Sing wild_0123456789
             -> Sing wild_0123456789
                -> Sing (Apply FooSym0 (Apply (Apply (:$) wild_0123456789) wild_0123456789))
@@ -253,7 +252,7 @@
       = let
           lambda ::
             forall wild_0123456789
-                   wild_0123456789. (GHC.Types.~) t (Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789) =>
+                   wild_0123456789. t ~ Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789 =>
             Sing wild_0123456789
             -> Sing wild_0123456789
                -> Sing (Apply TupSym0 (Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789))
@@ -269,8 +268,7 @@
         in lambda sWild_0123456789 sWild_0123456789
     sBaz_ SNothing
       = let
-          lambda ::
-            (GHC.Types.~) t NothingSym0 => Sing (Apply Baz_Sym0 NothingSym0)
+          lambda :: t ~ NothingSym0 => Sing (Apply Baz_Sym0 NothingSym0)
           lambda
             = let
                 sP :: Sing Let_0123456789PSym0
@@ -283,7 +281,7 @@
           lambda ::
             forall wild_0123456789
                    wild_0123456789
-                   wild_0123456789. (GHC.Types.~) t (Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789) wild_0123456789) wild_0123456789)) =>
+                   wild_0123456789. t ~ Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789) wild_0123456789) wild_0123456789) =>
             Sing wild_0123456789
             -> Sing wild_0123456789
                -> Sing wild_0123456789
@@ -306,7 +304,7 @@
     sBar (SJust sWild_0123456789)
       = let
           lambda ::
-            forall wild_0123456789. (GHC.Types.~) t (Apply JustSym0 wild_0123456789) =>
+            forall wild_0123456789. t ~ Apply JustSym0 wild_0123456789 =>
             Sing wild_0123456789
             -> Sing (Apply BarSym0 (Apply JustSym0 wild_0123456789))
           lambda wild_0123456789
@@ -319,14 +317,13 @@
         in lambda sWild_0123456789
     sBar SNothing
       = let
-          lambda ::
-            (GHC.Types.~) t NothingSym0 => Sing (Apply BarSym0 NothingSym0)
+          lambda :: t ~ NothingSym0 => Sing (Apply BarSym0 NothingSym0)
           lambda = SNothing
         in lambda
     sMaybePlus (SJust sN)
       = let
           lambda ::
-            forall n. (GHC.Types.~) t (Apply JustSym0 n) =>
+            forall n. t ~ Apply JustSym0 n =>
             Sing n -> Sing (Apply MaybePlusSym0 (Apply JustSym0 n))
           lambda n
             = applySing
@@ -339,9 +336,7 @@
         in lambda sN
     sMaybePlus SNothing
       = let
-          lambda ::
-            (GHC.Types.~) t NothingSym0 =>
-            Sing (Apply MaybePlusSym0 NothingSym0)
+          lambda :: t ~ NothingSym0 => Sing (Apply MaybePlusSym0 NothingSym0)
           lambda
             = let
                 sP :: Sing Let_0123456789PSym0
@@ -349,9 +344,7 @@
               in sP
         in lambda
     data instance Sing (z :: Baz)
-      = forall (n :: Nat)
-               (n :: Nat)
-               (n :: Nat). (GHC.Types.~) z (Baz n n n) =>
+      = forall (n :: Nat) (n :: Nat) (n :: Nat). z ~ Baz n n n =>
         SBaz (Sing n) (Sing n) (Sing n)
     type SBaz (z :: Baz) = Sing z
     instance SingKind (KProxy :: KProxy Baz) where
diff --git a/tests/compile-and-dump/Singletons/BoxUnBox.ghc78.template b/tests/compile-and-dump/Singletons/BoxUnBox.ghc78.template
--- a/tests/compile-and-dump/Singletons/BoxUnBox.ghc78.template
+++ b/tests/compile-and-dump/Singletons/BoxUnBox.ghc78.template
@@ -14,7 +14,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) FBoxSym0KindInference GHC.Tuple.())
     data FBoxSym0 (l :: TyFun a (Box a))
-      = forall arg. (GHC.Types.~) (KindOf (Apply FBoxSym0 arg)) (KindOf (FBoxSym1 arg)) =>
+      = forall arg. KindOf (Apply FBoxSym0 arg) ~ KindOf (FBoxSym1 arg) =>
         FBoxSym0KindInference
     type instance Apply FBoxSym0 l = FBoxSym1 l
     type UnBoxSym1 (t :: Box a) = UnBox t
@@ -22,7 +22,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) UnBoxSym0KindInference GHC.Tuple.())
     data UnBoxSym0 (l :: TyFun (Box a) a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply UnBoxSym0 arg)) (KindOf (UnBoxSym1 arg)) =>
+      = forall arg. KindOf (Apply UnBoxSym0 arg) ~ KindOf (UnBoxSym1 arg) =>
         UnBoxSym0KindInference
     type instance Apply UnBoxSym0 l = UnBoxSym1 l
     type family UnBox (a :: Box a) :: a where
@@ -31,12 +31,12 @@
     sUnBox (SFBox sA)
       = let
           lambda ::
-            forall a. (GHC.Types.~) t (Apply FBoxSym0 a) =>
+            forall a. t ~ Apply FBoxSym0 a =>
             Sing a -> Sing (Apply UnBoxSym0 (Apply FBoxSym0 a))
           lambda a = a
         in lambda sA
     data instance Sing (z :: Box a)
-      = forall (n :: a). (GHC.Types.~) z (FBox n) => SFBox (Sing n)
+      = forall (n :: a). z ~ FBox n => SFBox (Sing n)
     type SBox (z :: Box a) = Sing z
     instance SingKind (KProxy :: KProxy a) =>
              SingKind (KProxy :: KProxy (Box a)) where
diff --git a/tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template b/tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template
--- a/tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template
+++ b/tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template
@@ -46,7 +46,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
         Let_0123456789Scrutinee_0123456789Sym0KindInference
     type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
     type Let_0123456789Scrutinee_0123456789 x = x
@@ -60,7 +60,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -68,7 +68,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -76,7 +76,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Case_0123456789 x t where
@@ -89,7 +89,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
         Let_0123456789Scrutinee_0123456789Sym0KindInference
     type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
     type Let_0123456789Scrutinee_0123456789 x = x
@@ -98,14 +98,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789ZSym1KindInference GHC.Tuple.())
     data Let_0123456789ZSym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789ZSym1 l) arg)) (KindOf (Let_0123456789ZSym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789ZSym1 l) arg) ~ KindOf (Let_0123456789ZSym2 l arg) =>
         Let_0123456789ZSym1KindInference
     type instance Apply (Let_0123456789ZSym1 l) l = Let_0123456789ZSym2 l l
     instance SuppressUnusedWarnings Let_0123456789ZSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
     data Let_0123456789ZSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789ZSym0 arg)) (KindOf (Let_0123456789ZSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
         Let_0123456789ZSym0KindInference
     type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
     type Let_0123456789Z x y = (y :: a)
@@ -119,7 +119,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
         Let_0123456789Scrutinee_0123456789Sym1KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
@@ -128,7 +128,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
         Let_0123456789Scrutinee_0123456789Sym0KindInference
     type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
     type Let_0123456789Scrutinee_0123456789 a b =
@@ -143,7 +143,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
         Let_0123456789Scrutinee_0123456789Sym0KindInference
     type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
     type Let_0123456789Scrutinee_0123456789 d = Apply JustSym0 d
@@ -157,7 +157,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
         Let_0123456789Scrutinee_0123456789Sym1KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
@@ -166,7 +166,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
         Let_0123456789Scrutinee_0123456789Sym0KindInference
     type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
     type Let_0123456789Scrutinee_0123456789 d x = x
@@ -178,7 +178,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.())
     data Foo5Sym0 (l :: TyFun a a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo5Sym0 arg)) (KindOf (Foo5Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) =>
         Foo5Sym0KindInference
     type instance Apply Foo5Sym0 l = Foo5Sym1 l
     type Foo4Sym1 (t :: a) = Foo4 t
@@ -186,7 +186,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.())
     data Foo4Sym0 (l :: TyFun a a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo4Sym0 arg)) (KindOf (Foo4Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) =>
         Foo4Sym0KindInference
     type instance Apply Foo4Sym0 l = Foo4Sym1 l
     type Foo3Sym2 (t :: a) (t :: b) = Foo3 t t
@@ -194,14 +194,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo3Sym1KindInference GHC.Tuple.())
     data Foo3Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo3Sym1 l) arg)) (KindOf (Foo3Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo3Sym1 l) arg) ~ KindOf (Foo3Sym2 l arg) =>
         Foo3Sym1KindInference
     type instance Apply (Foo3Sym1 l) l = Foo3Sym2 l l
     instance SuppressUnusedWarnings Foo3Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
     data Foo3Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo3Sym0 arg)) (KindOf (Foo3Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
         Foo3Sym0KindInference
     type instance Apply Foo3Sym0 l = Foo3Sym1 l
     type Foo2Sym2 (t :: a) (t :: Maybe a) = Foo2 t t
@@ -209,14 +209,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.())
     data Foo2Sym1 (l :: a) (l :: TyFun (Maybe a) a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo2Sym1 l) arg)) (KindOf (Foo2Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) =>
         Foo2Sym1KindInference
     type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l
     instance SuppressUnusedWarnings Foo2Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
     data Foo2Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo2Sym0 arg)) (KindOf (Foo2Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
         Foo2Sym0KindInference
     type instance Apply Foo2Sym0 l = Foo2Sym1 l
     type Foo1Sym2 (t :: a) (t :: Maybe a) = Foo1 t t
@@ -224,14 +224,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.())
     data Foo1Sym1 (l :: a) (l :: TyFun (Maybe a) a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo1Sym1 l) arg)) (KindOf (Foo1Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) =>
         Foo1Sym1KindInference
     type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l
     instance SuppressUnusedWarnings Foo1Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
     data Foo1Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo1Sym0 arg)) (KindOf (Foo1Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
         Foo1Sym0KindInference
     type instance Apply Foo1Sym0 l = Foo1Sym1 l
     type family Foo5 (a :: a) :: a where
@@ -257,8 +257,7 @@
       Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t)
     sFoo5 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo5Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo5Sym0 x)
           lambda x
             = let
                 sScrutinee_0123456789 ::
@@ -293,8 +292,7 @@
         in lambda sX
     sFoo4 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo4Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo4Sym0 x)
           lambda x
             = let
                 sScrutinee_0123456789 ::
@@ -315,7 +313,7 @@
     sFoo3 sA sB
       = let
           lambda ::
-            forall a b. ((GHC.Types.~) t a, (GHC.Types.~) t b) =>
+            forall a b. (t ~ a, t ~ b) =>
             Sing a -> Sing b -> Sing (Apply (Apply Foo3Sym0 a) b)
           lambda a b
             = let
@@ -338,7 +336,7 @@
     sFoo2 sD _
       = let
           lambda ::
-            forall d wild. ((GHC.Types.~) t d, (GHC.Types.~) t wild) =>
+            forall d wild. (t ~ d, t ~ wild) =>
             Sing d -> Sing (Apply (Apply Foo2Sym0 d) wild)
           lambda d
             = let
@@ -358,7 +356,7 @@
     sFoo1 sD sX
       = let
           lambda ::
-            forall d x. ((GHC.Types.~) t d, (GHC.Types.~) t x) =>
+            forall d x. (t ~ d, t ~ x) =>
             Sing d -> Sing x -> Sing (Apply (Apply Foo1Sym0 d) x)
           lambda d x
             = let
diff --git a/tests/compile-and-dump/Singletons/Contains.ghc78.template b/tests/compile-and-dump/Singletons/Contains.ghc78.template
--- a/tests/compile-and-dump/Singletons/Contains.ghc78.template
+++ b/tests/compile-and-dump/Singletons/Contains.ghc78.template
@@ -13,14 +13,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) ContainsSym1KindInference GHC.Tuple.())
     data ContainsSym1 (l :: a) (l :: TyFun (GHC.Types.[] a) Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (ContainsSym1 l) arg)) (KindOf (ContainsSym2 l arg)) =>
+      = forall arg. KindOf (Apply (ContainsSym1 l) arg) ~ KindOf (ContainsSym2 l arg) =>
         ContainsSym1KindInference
     type instance Apply (ContainsSym1 l) l = ContainsSym2 l l
     instance SuppressUnusedWarnings ContainsSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) ContainsSym0KindInference GHC.Tuple.())
     data ContainsSym0 (l :: TyFun a (TyFun (GHC.Types.[] a) Bool -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply ContainsSym0 arg)) (KindOf (ContainsSym1 arg)) =>
+      = forall arg. KindOf (Apply ContainsSym0 arg) ~ KindOf (ContainsSym1 arg) =>
         ContainsSym0KindInference
     type instance Apply ContainsSym0 l = ContainsSym1 l
     type family Contains (a :: a) (a :: GHC.Types.[] a) :: Bool where
@@ -32,16 +32,14 @@
     sContains _ SNil
       = let
           lambda ::
-            forall wild. ((GHC.Types.~) t wild,
-                          (GHC.Types.~) t GHC.Types.[]) =>
+            forall wild. (t ~ wild, t ~ GHC.Types.[]) =>
             Sing (Apply (Apply ContainsSym0 wild) GHC.Types.[])
           lambda = SFalse
         in lambda
     sContains sElt (SCons sH sT)
       = let
           lambda ::
-            forall elt h t. ((GHC.Types.~) t elt,
-                             (GHC.Types.~) t (Apply (Apply (:$) h) t)) =>
+            forall elt h t. (t ~ elt, t ~ Apply (Apply (:$) h) t) =>
             Sing elt
             -> Sing h
                -> Sing t
diff --git a/tests/compile-and-dump/Singletons/DataValues.ghc78.template b/tests/compile-and-dump/Singletons/DataValues.ghc78.template
--- a/tests/compile-and-dump/Singletons/DataValues.ghc78.template
+++ b/tests/compile-and-dump/Singletons/DataValues.ghc78.template
@@ -22,14 +22,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.())
     data PairSym1 (l :: a) (l :: TyFun b (Pair a b))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (PairSym1 l) arg)) (KindOf (PairSym2 l arg)) =>
+      = forall arg. KindOf (Apply (PairSym1 l) arg) ~ KindOf (PairSym2 l arg) =>
         PairSym1KindInference
     type instance Apply (PairSym1 l) l = PairSym2 l l
     instance SuppressUnusedWarnings PairSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.())
     data PairSym0 (l :: TyFun a (TyFun b (Pair a b) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply PairSym0 arg)) (KindOf (PairSym1 arg)) =>
+      = forall arg. KindOf (Apply PairSym0 arg) ~ KindOf (PairSym1 arg) =>
         PairSym0KindInference
     type instance Apply PairSym0 l = PairSym1 l
     type AListSym0 = AList
@@ -86,8 +86,7 @@
           (applySing
              (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) SNil)
     data instance Sing (z :: Pair a b)
-      = forall (n :: a) (n :: b). (GHC.Types.~) z (Pair n n) =>
-        SPair (Sing n) (Sing n)
+      = forall (n :: a) (n :: b). z ~ Pair n n => SPair (Sing n) (Sing n)
     type SPair (z :: Pair a b) = Sing z
     instance (SingKind (KProxy :: KProxy a),
               SingKind (KProxy :: KProxy b)) =>
diff --git a/tests/compile-and-dump/Singletons/Error.ghc78.template b/tests/compile-and-dump/Singletons/Error.ghc78.template
--- a/tests/compile-and-dump/Singletons/Error.ghc78.template
+++ b/tests/compile-and-dump/Singletons/Error.ghc78.template
@@ -13,7 +13,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) HeadSym0KindInference GHC.Tuple.())
     data HeadSym0 (l :: TyFun (GHC.Types.[] a) a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply HeadSym0 arg)) (KindOf (HeadSym1 arg)) =>
+      = forall arg. KindOf (Apply HeadSym0 arg) ~ KindOf (HeadSym1 arg) =>
         HeadSym0KindInference
     type instance Apply HeadSym0 l = HeadSym1 l
     type family Head (a :: GHC.Types.[] a) :: a where
@@ -24,14 +24,13 @@
     sHead (SCons sA _)
       = let
           lambda ::
-            forall a wild. (GHC.Types.~) t (Apply (Apply (:$) a) wild) =>
+            forall a wild. t ~ Apply (Apply (:$) a) wild =>
             Sing a -> Sing (Apply HeadSym0 (Apply (Apply (:$) a) wild))
           lambda a = a
         in lambda sA
     sHead SNil
       = let
-          lambda ::
-            (GHC.Types.~) t GHC.Types.[] => Sing (Apply HeadSym0 GHC.Types.[])
+          lambda :: t ~ GHC.Types.[] => Sing (Apply HeadSym0 GHC.Types.[])
           lambda
             = applySing
                 (singFun1 (Proxy :: Proxy ErrorSym0) sError)
diff --git a/tests/compile-and-dump/Singletons/HigherOrder.ghc78.template b/tests/compile-and-dump/Singletons/HigherOrder.ghc78.template
--- a/tests/compile-and-dump/Singletons/HigherOrder.ghc78.template
+++ b/tests/compile-and-dump/Singletons/HigherOrder.ghc78.template
@@ -47,7 +47,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) LeftSym0KindInference GHC.Tuple.())
     data LeftSym0 (l :: TyFun a (Either a b))
-      = forall arg. (GHC.Types.~) (KindOf (Apply LeftSym0 arg)) (KindOf (LeftSym1 arg)) =>
+      = forall arg. KindOf (Apply LeftSym0 arg) ~ KindOf (LeftSym1 arg) =>
         LeftSym0KindInference
     type instance Apply LeftSym0 l = LeftSym1 l
     type RightSym1 (t :: b) = Right t
@@ -55,7 +55,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) RightSym0KindInference GHC.Tuple.())
     data RightSym0 (l :: TyFun b (Either a b))
-      = forall arg. (GHC.Types.~) (KindOf (Apply RightSym0 arg)) (KindOf (RightSym1 arg)) =>
+      = forall arg. KindOf (Apply RightSym0 arg) ~ KindOf (RightSym1 arg) =>
         RightSym0KindInference
     type instance Apply RightSym0 l = RightSym1 l
     type Let_0123456789Scrutinee_0123456789Sym4 t t t t =
@@ -66,7 +66,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym3 l l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg) =>
         Let_0123456789Scrutinee_0123456789Sym3KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) l = Let_0123456789Scrutinee_0123456789Sym4 l l l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym2 where
@@ -75,7 +75,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>
         Let_0123456789Scrutinee_0123456789Sym2KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where
@@ -84,7 +84,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
         Let_0123456789Scrutinee_0123456789Sym1KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
@@ -93,7 +93,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
         Let_0123456789Scrutinee_0123456789Sym0KindInference
     type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
     type Let_0123456789Scrutinee_0123456789 ns bs n b = b
@@ -108,7 +108,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
     data Lambda_0123456789Sym3 l l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym3 l l l) arg)) (KindOf (Lambda_0123456789Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
         Lambda_0123456789Sym3KindInference
     type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
@@ -116,7 +116,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -124,7 +124,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -132,7 +132,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type Let_0123456789Scrutinee_0123456789Sym4 t t t t =
@@ -143,7 +143,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym3 l l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg) =>
         Let_0123456789Scrutinee_0123456789Sym3KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) l = Let_0123456789Scrutinee_0123456789Sym4 l l l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym2 where
@@ -152,7 +152,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>
         Let_0123456789Scrutinee_0123456789Sym2KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where
@@ -161,7 +161,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
         Let_0123456789Scrutinee_0123456789Sym1KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
@@ -170,7 +170,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
         Let_0123456789Scrutinee_0123456789Sym0KindInference
     type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
     type Let_0123456789Scrutinee_0123456789 n
@@ -189,7 +189,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
     data Lambda_0123456789Sym3 l l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym3 l l l) arg)) (KindOf (Lambda_0123456789Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
         Lambda_0123456789Sym3KindInference
     type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
@@ -197,7 +197,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -205,7 +205,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -213,7 +213,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type FooSym3 (t :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
@@ -226,7 +226,7 @@
     data FooSym2 (l :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
                  (l :: TyFun a b -> *)
                  (l :: TyFun a b)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (FooSym2 l l) arg)) (KindOf (FooSym3 l l arg)) =>
+      = forall arg. KindOf (Apply (FooSym2 l l) arg) ~ KindOf (FooSym3 l l arg) =>
         FooSym2KindInference
     type instance Apply (FooSym2 l l) l = FooSym3 l l l
     instance SuppressUnusedWarnings FooSym1 where
@@ -234,7 +234,7 @@
         = snd (GHC.Tuple.(,) FooSym1KindInference GHC.Tuple.())
     data FooSym1 (l :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
                  (l :: TyFun (TyFun a b -> *) (TyFun a b -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (FooSym1 l) arg)) (KindOf (FooSym2 l arg)) =>
+      = forall arg. KindOf (Apply (FooSym1 l) arg) ~ KindOf (FooSym2 l arg) =>
         FooSym1KindInference
     type instance Apply (FooSym1 l) l = FooSym2 l l
     instance SuppressUnusedWarnings FooSym0 where
@@ -242,7 +242,7 @@
         = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
     data FooSym0 (l :: TyFun (TyFun (TyFun a b -> *) (TyFun a b -> *)
                               -> *) (TyFun (TyFun a b -> *) (TyFun a b -> *) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply FooSym0 arg)) (KindOf (FooSym1 arg)) =>
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
         FooSym0KindInference
     type instance Apply FooSym0 l = FooSym1 l
     type ZipWithSym3 (t :: TyFun a (TyFun b c -> *) -> *)
@@ -255,7 +255,7 @@
     data ZipWithSym2 (l :: TyFun a (TyFun b c -> *) -> *)
                      (l :: GHC.Types.[] a)
                      (l :: TyFun (GHC.Types.[] b) (GHC.Types.[] c))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (ZipWithSym2 l l) arg)) (KindOf (ZipWithSym3 l l arg)) =>
+      = forall arg. KindOf (Apply (ZipWithSym2 l l) arg) ~ KindOf (ZipWithSym3 l l arg) =>
         ZipWithSym2KindInference
     type instance Apply (ZipWithSym2 l l) l = ZipWithSym3 l l l
     instance SuppressUnusedWarnings ZipWithSym1 where
@@ -264,7 +264,7 @@
     data ZipWithSym1 (l :: TyFun a (TyFun b c -> *) -> *)
                      (l :: TyFun (GHC.Types.[] a) (TyFun (GHC.Types.[] b) (GHC.Types.[] c)
                                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (ZipWithSym1 l) arg)) (KindOf (ZipWithSym2 l arg)) =>
+      = forall arg. KindOf (Apply (ZipWithSym1 l) arg) ~ KindOf (ZipWithSym2 l arg) =>
         ZipWithSym1KindInference
     type instance Apply (ZipWithSym1 l) l = ZipWithSym2 l l
     instance SuppressUnusedWarnings ZipWithSym0 where
@@ -274,7 +274,7 @@
                                   -> *) (TyFun (GHC.Types.[] a) (TyFun (GHC.Types.[] b) (GHC.Types.[] c)
                                                                  -> *)
                                          -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply ZipWithSym0 arg)) (KindOf (ZipWithSym1 arg)) =>
+      = forall arg. KindOf (Apply ZipWithSym0 arg) ~ KindOf (ZipWithSym1 arg) =>
         ZipWithSym0KindInference
     type instance Apply ZipWithSym0 l = ZipWithSym1 l
     type SplungeSym2 (t :: GHC.Types.[] Nat) (t :: GHC.Types.[] Bool) =
@@ -284,7 +284,7 @@
         = snd (GHC.Tuple.(,) SplungeSym1KindInference GHC.Tuple.())
     data SplungeSym1 (l :: GHC.Types.[] Nat)
                      (l :: TyFun (GHC.Types.[] Bool) (GHC.Types.[] Nat))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (SplungeSym1 l) arg)) (KindOf (SplungeSym2 l arg)) =>
+      = forall arg. KindOf (Apply (SplungeSym1 l) arg) ~ KindOf (SplungeSym2 l arg) =>
         SplungeSym1KindInference
     type instance Apply (SplungeSym1 l) l = SplungeSym2 l l
     instance SuppressUnusedWarnings SplungeSym0 where
@@ -292,7 +292,7 @@
         = snd (GHC.Tuple.(,) SplungeSym0KindInference GHC.Tuple.())
     data SplungeSym0 (l :: TyFun (GHC.Types.[] Nat) (TyFun (GHC.Types.[] Bool) (GHC.Types.[] Nat)
                                                      -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply SplungeSym0 arg)) (KindOf (SplungeSym1 arg)) =>
+      = forall arg. KindOf (Apply SplungeSym0 arg) ~ KindOf (SplungeSym1 arg) =>
         SplungeSym0KindInference
     type instance Apply SplungeSym0 l = SplungeSym1 l
     type EtadSym2 (t :: GHC.Types.[] Nat) (t :: GHC.Types.[] Bool) =
@@ -302,7 +302,7 @@
         = snd (GHC.Tuple.(,) EtadSym1KindInference GHC.Tuple.())
     data EtadSym1 (l :: GHC.Types.[] Nat)
                   (l :: TyFun (GHC.Types.[] Bool) (GHC.Types.[] Nat))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (EtadSym1 l) arg)) (KindOf (EtadSym2 l arg)) =>
+      = forall arg. KindOf (Apply (EtadSym1 l) arg) ~ KindOf (EtadSym2 l arg) =>
         EtadSym1KindInference
     type instance Apply (EtadSym1 l) l = EtadSym2 l l
     instance SuppressUnusedWarnings EtadSym0 where
@@ -310,7 +310,7 @@
         = snd (GHC.Tuple.(,) EtadSym0KindInference GHC.Tuple.())
     data EtadSym0 (l :: TyFun (GHC.Types.[] Nat) (TyFun (GHC.Types.[] Bool) (GHC.Types.[] Nat)
                                                   -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply EtadSym0 arg)) (KindOf (EtadSym1 arg)) =>
+      = forall arg. KindOf (Apply EtadSym0 arg) ~ KindOf (EtadSym1 arg) =>
         EtadSym0KindInference
     type instance Apply EtadSym0 l = EtadSym1 l
     type LiftMaybeSym2 (t :: TyFun a b -> *) (t :: Maybe a) =
@@ -320,7 +320,7 @@
         = snd (GHC.Tuple.(,) LiftMaybeSym1KindInference GHC.Tuple.())
     data LiftMaybeSym1 (l :: TyFun a b -> *)
                        (l :: TyFun (Maybe a) (Maybe b))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (LiftMaybeSym1 l) arg)) (KindOf (LiftMaybeSym2 l arg)) =>
+      = forall arg. KindOf (Apply (LiftMaybeSym1 l) arg) ~ KindOf (LiftMaybeSym2 l arg) =>
         LiftMaybeSym1KindInference
     type instance Apply (LiftMaybeSym1 l) l = LiftMaybeSym2 l l
     instance SuppressUnusedWarnings LiftMaybeSym0 where
@@ -328,7 +328,7 @@
         = snd (GHC.Tuple.(,) LiftMaybeSym0KindInference GHC.Tuple.())
     data LiftMaybeSym0 (l :: TyFun (TyFun a b
                                     -> *) (TyFun (Maybe a) (Maybe b) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply LiftMaybeSym0 arg)) (KindOf (LiftMaybeSym1 arg)) =>
+      = forall arg. KindOf (Apply LiftMaybeSym0 arg) ~ KindOf (LiftMaybeSym1 arg) =>
         LiftMaybeSym0KindInference
     type instance Apply LiftMaybeSym0 l = LiftMaybeSym1 l
     type MapSym2 (t :: TyFun a b -> *) (t :: GHC.Types.[] a) = Map t t
@@ -337,7 +337,7 @@
         = snd (GHC.Tuple.(,) MapSym1KindInference GHC.Tuple.())
     data MapSym1 (l :: TyFun a b -> *)
                  (l :: TyFun (GHC.Types.[] a) (GHC.Types.[] b))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (MapSym1 l) arg)) (KindOf (MapSym2 l arg)) =>
+      = forall arg. KindOf (Apply (MapSym1 l) arg) ~ KindOf (MapSym2 l arg) =>
         MapSym1KindInference
     type instance Apply (MapSym1 l) l = MapSym2 l l
     instance SuppressUnusedWarnings MapSym0 where
@@ -345,7 +345,7 @@
         = snd (GHC.Tuple.(,) MapSym0KindInference GHC.Tuple.())
     data MapSym0 (l :: TyFun (TyFun a b
                               -> *) (TyFun (GHC.Types.[] a) (GHC.Types.[] b) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply MapSym0 arg)) (KindOf (MapSym1 arg)) =>
+      = forall arg. KindOf (Apply MapSym0 arg) ~ KindOf (MapSym1 arg) =>
         MapSym0KindInference
     type instance Apply MapSym0 l = MapSym1 l
     type family Foo (a :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
@@ -401,9 +401,7 @@
     sFoo sF sG sA
       = let
           lambda ::
-            forall f g a. ((GHC.Types.~) t f,
-                           (GHC.Types.~) t g,
-                           (GHC.Types.~) t a) =>
+            forall f g a. (t ~ f, t ~ g, t ~ a) =>
             Sing f
             -> Sing g -> Sing a -> Sing (Apply (Apply (Apply FooSym0 f) g) a)
           lambda f g a = applySing (applySing f g) a
@@ -411,9 +409,9 @@
     sZipWith sF (SCons sX sXs) (SCons sY sYs)
       = let
           lambda ::
-            forall f x xs y ys. ((GHC.Types.~) t f,
-                                 (GHC.Types.~) t (Apply (Apply (:$) x) xs),
-                                 (GHC.Types.~) t (Apply (Apply (:$) y) ys)) =>
+            forall f x xs y ys. (t ~ f,
+                                 t ~ Apply (Apply (:$) x) xs,
+                                 t ~ Apply (Apply (:$) y) ys) =>
             Sing f
             -> Sing x
                -> Sing xs
@@ -433,34 +431,32 @@
     sZipWith _ SNil SNil
       = let
           lambda ::
-            forall wild. ((GHC.Types.~) t wild,
-                          (GHC.Types.~) t GHC.Types.[],
-                          (GHC.Types.~) t GHC.Types.[]) =>
+            forall wild. (t ~ wild, t ~ GHC.Types.[], t ~ GHC.Types.[]) =>
             Sing (Apply (Apply (Apply ZipWithSym0 wild) GHC.Types.[]) GHC.Types.[])
           lambda = SNil
         in lambda
     sZipWith _ (SCons _ _) SNil
       = let
           lambda ::
-            forall wild wild wild. ((GHC.Types.~) t wild,
-                                    (GHC.Types.~) t (Apply (Apply (:$) wild) wild),
-                                    (GHC.Types.~) t GHC.Types.[]) =>
+            forall wild wild wild. (t ~ wild,
+                                    t ~ Apply (Apply (:$) wild) wild,
+                                    t ~ GHC.Types.[]) =>
             Sing (Apply (Apply (Apply ZipWithSym0 wild) (Apply (Apply (:$) wild) wild)) GHC.Types.[])
           lambda = SNil
         in lambda
     sZipWith _ SNil (SCons _ _)
       = let
           lambda ::
-            forall wild wild wild. ((GHC.Types.~) t wild,
-                                    (GHC.Types.~) t GHC.Types.[],
-                                    (GHC.Types.~) t (Apply (Apply (:$) wild) wild)) =>
+            forall wild wild wild. (t ~ wild,
+                                    t ~ GHC.Types.[],
+                                    t ~ Apply (Apply (:$) wild) wild) =>
             Sing (Apply (Apply (Apply ZipWithSym0 wild) GHC.Types.[]) (Apply (Apply (:$) wild) wild))
           lambda = SNil
         in lambda
     sSplunge sNs sBs
       = let
           lambda ::
-            forall ns bs. ((GHC.Types.~) t ns, (GHC.Types.~) t bs) =>
+            forall ns bs. (t ~ ns, t ~ bs) =>
             Sing ns -> Sing bs -> Sing (Apply (Apply SplungeSym0 ns) bs)
           lambda ns bs
             = applySing
@@ -505,8 +501,8 @@
     sEtad sA_0123456789 sA_0123456789
       = let
           lambda ::
-            forall a_0123456789 a_0123456789. ((GHC.Types.~) t a_0123456789,
-                                               (GHC.Types.~) t a_0123456789) =>
+            forall a_0123456789 a_0123456789. (t ~ a_0123456789,
+                                               t ~ a_0123456789) =>
             Sing a_0123456789
             -> Sing a_0123456789
                -> Sing (Apply (Apply EtadSym0 a_0123456789) a_0123456789)
@@ -556,8 +552,7 @@
     sLiftMaybe sF (SJust sX)
       = let
           lambda ::
-            forall f x. ((GHC.Types.~) t f,
-                         (GHC.Types.~) t (Apply JustSym0 x)) =>
+            forall f x. (t ~ f, t ~ Apply JustSym0 x) =>
             Sing f
             -> Sing x
                -> Sing (Apply (Apply LiftMaybeSym0 f) (Apply JustSym0 x))
@@ -568,23 +563,21 @@
     sLiftMaybe _ SNothing
       = let
           lambda ::
-            forall wild. ((GHC.Types.~) t wild, (GHC.Types.~) t NothingSym0) =>
+            forall wild. (t ~ wild, t ~ NothingSym0) =>
             Sing (Apply (Apply LiftMaybeSym0 wild) NothingSym0)
           lambda = SNothing
         in lambda
     sMap _ SNil
       = let
           lambda ::
-            forall wild. ((GHC.Types.~) t wild,
-                          (GHC.Types.~) t GHC.Types.[]) =>
+            forall wild. (t ~ wild, t ~ GHC.Types.[]) =>
             Sing (Apply (Apply MapSym0 wild) GHC.Types.[])
           lambda = SNil
         in lambda
     sMap sF (SCons sH sT)
       = let
           lambda ::
-            forall f h t. ((GHC.Types.~) t f,
-                           (GHC.Types.~) t (Apply (Apply (:$) h) t)) =>
+            forall f h t. (t ~ f, t ~ Apply (Apply (:$) h) t) =>
             Sing f
             -> Sing h
                -> Sing t
@@ -596,8 +589,8 @@
                    (applySing (singFun2 (Proxy :: Proxy MapSym0) sMap) f) t)
         in lambda sF sH sT
     data instance Sing (z :: Either a b)
-      = forall (n :: a). (GHC.Types.~) z (Left n) => SLeft (Sing n) |
-        forall (n :: b). (GHC.Types.~) z (Right n) => SRight (Sing n)
+      = forall (n :: a). z ~ Left n => SLeft (Sing n) |
+        forall (n :: b). z ~ Right n => SRight (Sing n)
     type SEither (z :: Either a b) = Sing z
     instance (SingKind (KProxy :: KProxy a),
               SingKind (KProxy :: KProxy b)) =>
diff --git a/tests/compile-and-dump/Singletons/LambdaCase.ghc78.template b/tests/compile-and-dump/Singletons/LambdaCase.ghc78.template
--- a/tests/compile-and-dump/Singletons/LambdaCase.ghc78.template
+++ b/tests/compile-and-dump/Singletons/LambdaCase.ghc78.template
@@ -40,7 +40,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -48,7 +48,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -56,7 +56,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Case_0123456789 d x_0123456789 t where
@@ -70,7 +70,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -78,7 +78,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Case_0123456789 d x x_0123456789 t where
@@ -92,7 +92,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -100,7 +100,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -108,7 +108,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type Foo3Sym2 (t :: a) (t :: b) = Foo3 t t
@@ -116,14 +116,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo3Sym1KindInference GHC.Tuple.())
     data Foo3Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo3Sym1 l) arg)) (KindOf (Foo3Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo3Sym1 l) arg) ~ KindOf (Foo3Sym2 l arg) =>
         Foo3Sym1KindInference
     type instance Apply (Foo3Sym1 l) l = Foo3Sym2 l l
     instance SuppressUnusedWarnings Foo3Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
     data Foo3Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo3Sym0 arg)) (KindOf (Foo3Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
         Foo3Sym0KindInference
     type instance Apply Foo3Sym0 l = Foo3Sym1 l
     type Foo2Sym2 (t :: a) (t :: Maybe a) = Foo2 t t
@@ -131,14 +131,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.())
     data Foo2Sym1 (l :: a) (l :: TyFun (Maybe a) a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo2Sym1 l) arg)) (KindOf (Foo2Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) =>
         Foo2Sym1KindInference
     type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l
     instance SuppressUnusedWarnings Foo2Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
     data Foo2Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo2Sym0 arg)) (KindOf (Foo2Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
         Foo2Sym0KindInference
     type instance Apply Foo2Sym0 l = Foo2Sym1 l
     type Foo1Sym2 (t :: a) (t :: Maybe a) = Foo1 t t
@@ -146,14 +146,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.())
     data Foo1Sym1 (l :: a) (l :: TyFun (Maybe a) a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo1Sym1 l) arg)) (KindOf (Foo1Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) =>
         Foo1Sym1KindInference
     type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l
     instance SuppressUnusedWarnings Foo1Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
     data Foo1Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo1Sym0 arg)) (KindOf (Foo1Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
         Foo1Sym0KindInference
     type instance Apply Foo1Sym0 l = Foo1Sym1 l
     type family Foo3 (a :: a) (a :: b) :: a where
@@ -174,7 +174,7 @@
     sFoo3 sA sB
       = let
           lambda ::
-            forall a b. ((GHC.Types.~) t a, (GHC.Types.~) t b) =>
+            forall a b. (t ~ a, t ~ b) =>
             Sing a -> Sing b -> Sing (Apply (Apply Foo3Sym0 a) b)
           lambda a b
             = applySing
@@ -203,7 +203,7 @@
     sFoo2 sD _
       = let
           lambda ::
-            forall d wild. ((GHC.Types.~) t d, (GHC.Types.~) t wild) =>
+            forall d wild. (t ~ d, t ~ wild) =>
             Sing d -> Sing (Apply (Apply Foo2Sym0 d) wild)
           lambda d
             = applySing
@@ -236,7 +236,7 @@
     sFoo1 sD sX
       = let
           lambda ::
-            forall d x. ((GHC.Types.~) t d, (GHC.Types.~) t x) =>
+            forall d x. (t ~ d, t ~ x) =>
             Sing d -> Sing x -> Sing (Apply (Apply Foo1Sym0 d) x)
           lambda d x
             = applySing
diff --git a/tests/compile-and-dump/Singletons/Lambdas.ghc78.template b/tests/compile-and-dump/Singletons/Lambdas.ghc78.template
--- a/tests/compile-and-dump/Singletons/Lambdas.ghc78.template
+++ b/tests/compile-and-dump/Singletons/Lambdas.ghc78.template
@@ -46,14 +46,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) FooSym1KindInference GHC.Tuple.())
     data FooSym1 (l :: a) (l :: TyFun b (Foo a b))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (FooSym1 l) arg)) (KindOf (FooSym2 l arg)) =>
+      = forall arg. KindOf (Apply (FooSym1 l) arg) ~ KindOf (FooSym2 l arg) =>
         FooSym1KindInference
     type instance Apply (FooSym1 l) l = FooSym2 l l
     instance SuppressUnusedWarnings FooSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
     data FooSym0 (l :: TyFun a (TyFun b (Foo a b) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply FooSym0 arg)) (KindOf (FooSym1 arg)) =>
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
         FooSym0KindInference
     type instance Apply FooSym0 l = FooSym1 l
     type family Case_0123456789 x arg_0123456789 t where
@@ -66,7 +66,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -74,7 +74,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Case_0123456789 x y arg_0123456789 t where
@@ -87,7 +87,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -95,7 +95,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -103,7 +103,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Case_0123456789 a b x arg_0123456789 t where
@@ -116,7 +116,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
     data Lambda_0123456789Sym3 l l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym3 l l l) arg)) (KindOf (Lambda_0123456789Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
         Lambda_0123456789Sym3KindInference
     type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
@@ -124,7 +124,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -132,7 +132,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -140,7 +140,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Lambda_0123456789 a b t where
@@ -151,7 +151,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -159,7 +159,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -167,7 +167,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Lambda_0123456789 x y t where
@@ -178,7 +178,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -186,7 +186,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -194,7 +194,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Case_0123456789 x
@@ -212,7 +212,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym4KindInference GHC.Tuple.())
     data Lambda_0123456789Sym4 l l l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym4 l l l l) arg)) (KindOf (Lambda_0123456789Sym5 l l l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym4 l l l l) arg) ~ KindOf (Lambda_0123456789Sym5 l l l l arg) =>
         Lambda_0123456789Sym4KindInference
     type instance Apply (Lambda_0123456789Sym4 l l l l) l = Lambda_0123456789Sym5 l l l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
@@ -220,7 +220,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
     data Lambda_0123456789Sym3 l l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym3 l l l) arg)) (KindOf (Lambda_0123456789Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
         Lambda_0123456789Sym3KindInference
     type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
@@ -228,7 +228,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -236,7 +236,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -244,7 +244,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Lambda_0123456789 x t where
@@ -255,7 +255,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -263,7 +263,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Case_0123456789 x y arg_0123456789 t where
@@ -276,7 +276,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -284,7 +284,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -292,7 +292,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Case_0123456789 x arg_0123456789 a_0123456789 t where
@@ -305,7 +305,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -313,7 +313,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -321,7 +321,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Lambda_0123456789 a_0123456789 a_0123456789 t t where
@@ -332,7 +332,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
     data Lambda_0123456789Sym3 l l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym3 l l l) arg)) (KindOf (Lambda_0123456789Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
         Lambda_0123456789Sym3KindInference
     type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
@@ -340,7 +340,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -348,7 +348,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -356,7 +356,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type Foo8Sym1 (t :: Foo a b) = Foo8 t
@@ -364,7 +364,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo8Sym0KindInference GHC.Tuple.())
     data Foo8Sym0 (l :: TyFun (Foo a b) a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo8Sym0 arg)) (KindOf (Foo8Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo8Sym0 arg) ~ KindOf (Foo8Sym1 arg) =>
         Foo8Sym0KindInference
     type instance Apply Foo8Sym0 l = Foo8Sym1 l
     type Foo7Sym2 (t :: a) (t :: b) = Foo7 t t
@@ -372,14 +372,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo7Sym1KindInference GHC.Tuple.())
     data Foo7Sym1 (l :: a) (l :: TyFun b b)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo7Sym1 l) arg)) (KindOf (Foo7Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo7Sym1 l) arg) ~ KindOf (Foo7Sym2 l arg) =>
         Foo7Sym1KindInference
     type instance Apply (Foo7Sym1 l) l = Foo7Sym2 l l
     instance SuppressUnusedWarnings Foo7Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo7Sym0KindInference GHC.Tuple.())
     data Foo7Sym0 (l :: TyFun a (TyFun b b -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo7Sym0 arg)) (KindOf (Foo7Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo7Sym0 arg) ~ KindOf (Foo7Sym1 arg) =>
         Foo7Sym0KindInference
     type instance Apply Foo7Sym0 l = Foo7Sym1 l
     type Foo6Sym2 (t :: a) (t :: b) = Foo6 t t
@@ -387,14 +387,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo6Sym1KindInference GHC.Tuple.())
     data Foo6Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo6Sym1 l) arg)) (KindOf (Foo6Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo6Sym1 l) arg) ~ KindOf (Foo6Sym2 l arg) =>
         Foo6Sym1KindInference
     type instance Apply (Foo6Sym1 l) l = Foo6Sym2 l l
     instance SuppressUnusedWarnings Foo6Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo6Sym0KindInference GHC.Tuple.())
     data Foo6Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo6Sym0 arg)) (KindOf (Foo6Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo6Sym0 arg) ~ KindOf (Foo6Sym1 arg) =>
         Foo6Sym0KindInference
     type instance Apply Foo6Sym0 l = Foo6Sym1 l
     type Foo5Sym2 (t :: a) (t :: b) = Foo5 t t
@@ -402,14 +402,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo5Sym1KindInference GHC.Tuple.())
     data Foo5Sym1 (l :: a) (l :: TyFun b b)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo5Sym1 l) arg)) (KindOf (Foo5Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo5Sym1 l) arg) ~ KindOf (Foo5Sym2 l arg) =>
         Foo5Sym1KindInference
     type instance Apply (Foo5Sym1 l) l = Foo5Sym2 l l
     instance SuppressUnusedWarnings Foo5Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.())
     data Foo5Sym0 (l :: TyFun a (TyFun b b -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo5Sym0 arg)) (KindOf (Foo5Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) =>
         Foo5Sym0KindInference
     type instance Apply Foo5Sym0 l = Foo5Sym1 l
     type Foo4Sym3 (t :: a) (t :: b) (t :: c) = Foo4 t t t
@@ -417,21 +417,21 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo4Sym2KindInference GHC.Tuple.())
     data Foo4Sym2 (l :: a) (l :: b) (l :: TyFun c a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo4Sym2 l l) arg)) (KindOf (Foo4Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Foo4Sym2 l l) arg) ~ KindOf (Foo4Sym3 l l arg) =>
         Foo4Sym2KindInference
     type instance Apply (Foo4Sym2 l l) l = Foo4Sym3 l l l
     instance SuppressUnusedWarnings Foo4Sym1 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo4Sym1KindInference GHC.Tuple.())
     data Foo4Sym1 (l :: a) (l :: TyFun b (TyFun c a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo4Sym1 l) arg)) (KindOf (Foo4Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo4Sym1 l) arg) ~ KindOf (Foo4Sym2 l arg) =>
         Foo4Sym1KindInference
     type instance Apply (Foo4Sym1 l) l = Foo4Sym2 l l
     instance SuppressUnusedWarnings Foo4Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.())
     data Foo4Sym0 (l :: TyFun a (TyFun b (TyFun c a -> *) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo4Sym0 arg)) (KindOf (Foo4Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) =>
         Foo4Sym0KindInference
     type instance Apply Foo4Sym0 l = Foo4Sym1 l
     type Foo3Sym1 (t :: a) = Foo3 t
@@ -439,7 +439,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
     data Foo3Sym0 (l :: TyFun a a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo3Sym0 arg)) (KindOf (Foo3Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
         Foo3Sym0KindInference
     type instance Apply Foo3Sym0 l = Foo3Sym1 l
     type Foo2Sym2 (t :: a) (t :: b) = Foo2 t t
@@ -447,14 +447,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.())
     data Foo2Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo2Sym1 l) arg)) (KindOf (Foo2Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) =>
         Foo2Sym1KindInference
     type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l
     instance SuppressUnusedWarnings Foo2Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
     data Foo2Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo2Sym0 arg)) (KindOf (Foo2Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
         Foo2Sym0KindInference
     type instance Apply Foo2Sym0 l = Foo2Sym1 l
     type Foo1Sym2 (t :: a) (t :: b) = Foo1 t t
@@ -462,14 +462,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.())
     data Foo1Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo1Sym1 l) arg)) (KindOf (Foo1Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) =>
         Foo1Sym1KindInference
     type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l
     instance SuppressUnusedWarnings Foo1Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
     data Foo1Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo1Sym0 arg)) (KindOf (Foo1Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
         Foo1Sym0KindInference
     type instance Apply Foo1Sym0 l = Foo1Sym1 l
     type Foo0Sym2 (t :: a) (t :: b) = Foo0 t t
@@ -477,14 +477,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo0Sym1KindInference GHC.Tuple.())
     data Foo0Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Foo0Sym1 l) arg)) (KindOf (Foo0Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Foo0Sym1 l) arg) ~ KindOf (Foo0Sym2 l arg) =>
         Foo0Sym1KindInference
     type instance Apply (Foo0Sym1 l) l = Foo0Sym2 l l
     instance SuppressUnusedWarnings Foo0Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo0Sym0KindInference GHC.Tuple.())
     data Foo0Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo0Sym0 arg)) (KindOf (Foo0Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo0Sym0 arg) ~ KindOf (Foo0Sym1 arg) =>
         Foo0Sym0KindInference
     type instance Apply Foo0Sym0 l = Foo0Sym1 l
     type family Foo8 (a :: Foo a b) :: a where
@@ -531,8 +531,7 @@
       Sing t -> Sing t -> Sing (Apply (Apply Foo0Sym0 t) t)
     sFoo8 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo8Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo8Sym0 x)
           lambda x
             = applySing
                 (singFun1
@@ -559,7 +558,7 @@
     sFoo7 sX sY
       = let
           lambda ::
-            forall x y. ((GHC.Types.~) t x, (GHC.Types.~) t y) =>
+            forall x y. (t ~ x, t ~ y) =>
             Sing x -> Sing y -> Sing (Apply (Apply Foo7Sym0 x) y)
           lambda x y
             = applySing
@@ -588,7 +587,7 @@
     sFoo6 sA sB
       = let
           lambda ::
-            forall a b. ((GHC.Types.~) t a, (GHC.Types.~) t b) =>
+            forall a b. (t ~ a, t ~ b) =>
             Sing a -> Sing b -> Sing (Apply (Apply Foo6Sym0 a) b)
           lambda a b
             = applySing
@@ -626,7 +625,7 @@
     sFoo5 sX sY
       = let
           lambda ::
-            forall x y. ((GHC.Types.~) t x, (GHC.Types.~) t y) =>
+            forall x y. (t ~ x, t ~ y) =>
             Sing x -> Sing y -> Sing (Apply (Apply Foo5Sym0 x) y)
           lambda x y
             = applySing
@@ -644,9 +643,7 @@
     sFoo4 sX sY sZ
       = let
           lambda ::
-            forall x y z. ((GHC.Types.~) t x,
-                           (GHC.Types.~) t y,
-                           (GHC.Types.~) t z) =>
+            forall x y z. (t ~ x, t ~ y, t ~ z) =>
             Sing x
             -> Sing y -> Sing z -> Sing (Apply (Apply (Apply Foo4Sym0 x) y) z)
           lambda x y z
@@ -683,8 +680,7 @@
         in lambda sX sY sZ
     sFoo3 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo3Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo3Sym0 x)
           lambda x
             = applySing
                 (singFun1
@@ -700,7 +696,7 @@
     sFoo2 sX sY
       = let
           lambda ::
-            forall x y. ((GHC.Types.~) t x, (GHC.Types.~) t y) =>
+            forall x y. (t ~ x, t ~ y) =>
             Sing x -> Sing y -> Sing (Apply (Apply Foo2Sym0 x) y)
           lambda x y
             = applySing
@@ -726,8 +722,7 @@
     sFoo1 sX sA_0123456789
       = let
           lambda ::
-            forall x a_0123456789. ((GHC.Types.~) t x,
-                                    (GHC.Types.~) t a_0123456789) =>
+            forall x a_0123456789. (t ~ x, t ~ a_0123456789) =>
             Sing x
             -> Sing a_0123456789
                -> Sing (Apply (Apply Foo1Sym0 x) a_0123456789)
@@ -756,8 +751,8 @@
     sFoo0 sA_0123456789 sA_0123456789
       = let
           lambda ::
-            forall a_0123456789 a_0123456789. ((GHC.Types.~) t a_0123456789,
-                                               (GHC.Types.~) t a_0123456789) =>
+            forall a_0123456789 a_0123456789. (t ~ a_0123456789,
+                                               t ~ a_0123456789) =>
             Sing a_0123456789
             -> Sing a_0123456789
                -> Sing (Apply (Apply Foo0Sym0 a_0123456789) a_0123456789)
@@ -780,8 +775,7 @@
                 a_0123456789
         in lambda sA_0123456789 sA_0123456789
     data instance Sing (z :: Foo a b)
-      = forall (n :: a) (n :: b). (GHC.Types.~) z (Foo n n) =>
-        SFoo (Sing n) (Sing n)
+      = forall (n :: a) (n :: b). z ~ Foo n n => SFoo (Sing n) (Sing n)
     type SFoo (z :: Foo a b) = Sing z
     instance (SingKind (KProxy :: KProxy a),
               SingKind (KProxy :: KProxy b)) =>
diff --git a/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc78.template b/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc78.template
--- a/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc78.template
+++ b/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc78.template
@@ -20,7 +20,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type BarSym0 = Bar
diff --git a/tests/compile-and-dump/Singletons/LetStatements.ghc78.template b/tests/compile-and-dump/Singletons/LetStatements.ghc78.template
--- a/tests/compile-and-dump/Singletons/LetStatements.ghc78.template
+++ b/tests/compile-and-dump/Singletons/LetStatements.ghc78.template
@@ -199,7 +199,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789YSym0KindInference GHC.Tuple.())
     data Let_0123456789YSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789YSym0 arg)) (KindOf (Let_0123456789YSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789YSym0 arg) ~ KindOf (Let_0123456789YSym1 arg) =>
         Let_0123456789YSym0KindInference
     type instance Apply Let_0123456789YSym0 l = Let_0123456789YSym1 l
     type Let_0123456789ZSym1 t = Let_0123456789Z t
@@ -207,7 +207,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
     data Let_0123456789ZSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789ZSym0 arg)) (KindOf (Let_0123456789ZSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
         Let_0123456789ZSym0KindInference
     type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
     type Let_0123456789X_0123456789Sym1 t =
@@ -218,7 +218,7 @@
             (GHC.Tuple.(,)
                Let_0123456789X_0123456789Sym0KindInference GHC.Tuple.())
     data Let_0123456789X_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789X_0123456789Sym0 arg)) (KindOf (Let_0123456789X_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789X_0123456789Sym0 arg) ~ KindOf (Let_0123456789X_0123456789Sym1 arg) =>
         Let_0123456789X_0123456789Sym0KindInference
     type instance Apply Let_0123456789X_0123456789Sym0 l = Let_0123456789X_0123456789Sym1 l
     type Let_0123456789Y x =
@@ -233,7 +233,7 @@
         = snd
             (GHC.Tuple.(,) Let_0123456789BarSym0KindInference GHC.Tuple.())
     data Let_0123456789BarSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789BarSym0 arg)) (KindOf (Let_0123456789BarSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789BarSym0 arg) ~ KindOf (Let_0123456789BarSym1 arg) =>
         Let_0123456789BarSym0KindInference
     type instance Apply Let_0123456789BarSym0 l = Let_0123456789BarSym1 l
     type Let_0123456789Bar x = (x :: a)
@@ -244,7 +244,7 @@
         = snd
             (GHC.Tuple.(,) Let_0123456789:+Sym2KindInference GHC.Tuple.())
     data Let_0123456789:+Sym2 l (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789:+Sym2 l l) arg)) (KindOf (Let_0123456789:+Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789:+Sym2 l l) arg) ~ KindOf (Let_0123456789:+Sym3 l l arg) =>
         Let_0123456789:+Sym2KindInference
     type instance Apply (Let_0123456789:+Sym2 l l) l = Let_0123456789:+Sym3 l l l
     instance SuppressUnusedWarnings Let_0123456789:+Sym1 where
@@ -252,7 +252,7 @@
         = snd
             (GHC.Tuple.(,) Let_0123456789:+Sym1KindInference GHC.Tuple.())
     data Let_0123456789:+Sym1 l (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789:+Sym1 l) arg)) (KindOf (Let_0123456789:+Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789:+Sym1 l) arg) ~ KindOf (Let_0123456789:+Sym2 l arg) =>
         Let_0123456789:+Sym1KindInference
     type instance Apply (Let_0123456789:+Sym1 l) l = Let_0123456789:+Sym2 l l
     instance SuppressUnusedWarnings Let_0123456789:+Sym0 where
@@ -260,7 +260,7 @@
         = snd
             (GHC.Tuple.(,) Let_0123456789:+Sym0KindInference GHC.Tuple.())
     data Let_0123456789:+Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789:+Sym0 arg)) (KindOf (Let_0123456789:+Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789:+Sym0 arg) ~ KindOf (Let_0123456789:+Sym1 arg) =>
         Let_0123456789:+Sym0KindInference
     type instance Apply Let_0123456789:+Sym0 l = Let_0123456789:+Sym1 l
     type family Let_0123456789:+ x (a :: Nat) (a :: Nat) :: Nat where
@@ -271,7 +271,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
     data Let_0123456789ZSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789ZSym0 arg)) (KindOf (Let_0123456789ZSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
         Let_0123456789ZSym0KindInference
     type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
     type Let_0123456789:+Sym3 t (t :: Nat) (t :: Nat) =
@@ -281,7 +281,7 @@
         = snd
             (GHC.Tuple.(,) Let_0123456789:+Sym2KindInference GHC.Tuple.())
     data Let_0123456789:+Sym2 l (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789:+Sym2 l l) arg)) (KindOf (Let_0123456789:+Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789:+Sym2 l l) arg) ~ KindOf (Let_0123456789:+Sym3 l l arg) =>
         Let_0123456789:+Sym2KindInference
     type instance Apply (Let_0123456789:+Sym2 l l) l = Let_0123456789:+Sym3 l l l
     instance SuppressUnusedWarnings Let_0123456789:+Sym1 where
@@ -289,7 +289,7 @@
         = snd
             (GHC.Tuple.(,) Let_0123456789:+Sym1KindInference GHC.Tuple.())
     data Let_0123456789:+Sym1 l (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789:+Sym1 l) arg)) (KindOf (Let_0123456789:+Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789:+Sym1 l) arg) ~ KindOf (Let_0123456789:+Sym2 l arg) =>
         Let_0123456789:+Sym1KindInference
     type instance Apply (Let_0123456789:+Sym1 l) l = Let_0123456789:+Sym2 l l
     instance SuppressUnusedWarnings Let_0123456789:+Sym0 where
@@ -297,7 +297,7 @@
         = snd
             (GHC.Tuple.(,) Let_0123456789:+Sym0KindInference GHC.Tuple.())
     data Let_0123456789:+Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789:+Sym0 arg)) (KindOf (Let_0123456789:+Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789:+Sym0 arg) ~ KindOf (Let_0123456789:+Sym1 arg) =>
         Let_0123456789:+Sym0KindInference
     type instance Apply Let_0123456789:+Sym0 l = Let_0123456789:+Sym1 l
     type Let_0123456789Z x = (x :: Nat)
@@ -311,7 +311,7 @@
         = snd
             (GHC.Tuple.(,) Let_0123456789:+Sym2KindInference GHC.Tuple.())
     data Let_0123456789:+Sym2 l (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789:+Sym2 l l) arg)) (KindOf (Let_0123456789:+Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789:+Sym2 l l) arg) ~ KindOf (Let_0123456789:+Sym3 l l arg) =>
         Let_0123456789:+Sym2KindInference
     type instance Apply (Let_0123456789:+Sym2 l l) l = Let_0123456789:+Sym3 l l l
     instance SuppressUnusedWarnings Let_0123456789:+Sym1 where
@@ -319,7 +319,7 @@
         = snd
             (GHC.Tuple.(,) Let_0123456789:+Sym1KindInference GHC.Tuple.())
     data Let_0123456789:+Sym1 l (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789:+Sym1 l) arg)) (KindOf (Let_0123456789:+Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789:+Sym1 l) arg) ~ KindOf (Let_0123456789:+Sym2 l arg) =>
         Let_0123456789:+Sym1KindInference
     type instance Apply (Let_0123456789:+Sym1 l) l = Let_0123456789:+Sym2 l l
     instance SuppressUnusedWarnings Let_0123456789:+Sym0 where
@@ -327,7 +327,7 @@
         = snd
             (GHC.Tuple.(,) Let_0123456789:+Sym0KindInference GHC.Tuple.())
     data Let_0123456789:+Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789:+Sym0 arg)) (KindOf (Let_0123456789:+Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789:+Sym0 arg) ~ KindOf (Let_0123456789:+Sym1 arg) =>
         Let_0123456789:+Sym0KindInference
     type instance Apply Let_0123456789:+Sym0 l = Let_0123456789:+Sym1 l
     type family Let_0123456789:+ x (a :: Nat) (a :: Nat) :: Nat where
@@ -341,7 +341,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -349,7 +349,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -357,7 +357,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type Let_0123456789ZSym2 t (t :: Nat) = Let_0123456789Z t t
@@ -365,14 +365,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789ZSym1KindInference GHC.Tuple.())
     data Let_0123456789ZSym1 l (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789ZSym1 l) arg)) (KindOf (Let_0123456789ZSym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789ZSym1 l) arg) ~ KindOf (Let_0123456789ZSym2 l arg) =>
         Let_0123456789ZSym1KindInference
     type instance Apply (Let_0123456789ZSym1 l) l = Let_0123456789ZSym2 l l
     instance SuppressUnusedWarnings Let_0123456789ZSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
     data Let_0123456789ZSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789ZSym0 arg)) (KindOf (Let_0123456789ZSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
         Let_0123456789ZSym0KindInference
     type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
     type family Let_0123456789Z x (a :: Nat) :: Nat where
@@ -385,7 +385,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -393,7 +393,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type Let_0123456789ZSym1 t = Let_0123456789Z t
@@ -401,7 +401,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
     data Let_0123456789ZSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789ZSym0 arg)) (KindOf (Let_0123456789ZSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
         Let_0123456789ZSym0KindInference
     type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
     type Let_0123456789Z x =
@@ -411,7 +411,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789XSym0KindInference GHC.Tuple.())
     data Let_0123456789XSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789XSym0 arg)) (KindOf (Let_0123456789XSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789XSym0 arg) ~ KindOf (Let_0123456789XSym1 arg) =>
         Let_0123456789XSym0KindInference
     type instance Apply Let_0123456789XSym0 l = Let_0123456789XSym1 l
     type Let_0123456789X x = (ZeroSym0 :: Nat)
@@ -420,14 +420,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789FSym1KindInference GHC.Tuple.())
     data Let_0123456789FSym1 l (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789FSym1 l) arg)) (KindOf (Let_0123456789FSym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789FSym1 l) arg) ~ KindOf (Let_0123456789FSym2 l arg) =>
         Let_0123456789FSym1KindInference
     type instance Apply (Let_0123456789FSym1 l) l = Let_0123456789FSym2 l l
     instance SuppressUnusedWarnings Let_0123456789FSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789FSym0KindInference GHC.Tuple.())
     data Let_0123456789FSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789FSym0 arg)) (KindOf (Let_0123456789FSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789FSym0 arg) ~ KindOf (Let_0123456789FSym1 arg) =>
         Let_0123456789FSym0KindInference
     type instance Apply Let_0123456789FSym0 l = Let_0123456789FSym1 l
     type family Let_0123456789F x (a :: Nat) :: Nat where
@@ -437,7 +437,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
     data Let_0123456789ZSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789ZSym0 arg)) (KindOf (Let_0123456789ZSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
         Let_0123456789ZSym0KindInference
     type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
     type Let_0123456789Z x = (Apply (Let_0123456789FSym1 x) x :: Nat)
@@ -446,14 +446,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789ZSym1KindInference GHC.Tuple.())
     data Let_0123456789ZSym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789ZSym1 l) arg)) (KindOf (Let_0123456789ZSym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789ZSym1 l) arg) ~ KindOf (Let_0123456789ZSym2 l arg) =>
         Let_0123456789ZSym1KindInference
     type instance Apply (Let_0123456789ZSym1 l) l = Let_0123456789ZSym2 l l
     instance SuppressUnusedWarnings Let_0123456789ZSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
     data Let_0123456789ZSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789ZSym0 arg)) (KindOf (Let_0123456789ZSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
         Let_0123456789ZSym0KindInference
     type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
     type Let_0123456789Z x y = (Apply SuccSym0 y :: Nat)
@@ -462,14 +462,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789FSym1KindInference GHC.Tuple.())
     data Let_0123456789FSym1 l (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789FSym1 l) arg)) (KindOf (Let_0123456789FSym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789FSym1 l) arg) ~ KindOf (Let_0123456789FSym2 l arg) =>
         Let_0123456789FSym1KindInference
     type instance Apply (Let_0123456789FSym1 l) l = Let_0123456789FSym2 l l
     instance SuppressUnusedWarnings Let_0123456789FSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789FSym0KindInference GHC.Tuple.())
     data Let_0123456789FSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789FSym0 arg)) (KindOf (Let_0123456789FSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789FSym0 arg) ~ KindOf (Let_0123456789FSym1 arg) =>
         Let_0123456789FSym0KindInference
     type instance Apply Let_0123456789FSym0 l = Let_0123456789FSym1 l
     type family Let_0123456789F x (a :: Nat) :: Nat where
@@ -479,14 +479,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789FSym1KindInference GHC.Tuple.())
     data Let_0123456789FSym1 l (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789FSym1 l) arg)) (KindOf (Let_0123456789FSym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789FSym1 l) arg) ~ KindOf (Let_0123456789FSym2 l arg) =>
         Let_0123456789FSym1KindInference
     type instance Apply (Let_0123456789FSym1 l) l = Let_0123456789FSym2 l l
     instance SuppressUnusedWarnings Let_0123456789FSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789FSym0KindInference GHC.Tuple.())
     data Let_0123456789FSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789FSym0 arg)) (KindOf (Let_0123456789FSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789FSym0 arg) ~ KindOf (Let_0123456789FSym1 arg) =>
         Let_0123456789FSym0KindInference
     type instance Apply Let_0123456789FSym0 l = Let_0123456789FSym1 l
     type family Let_0123456789F x (a :: Nat) :: Nat where
@@ -496,7 +496,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789YSym0KindInference GHC.Tuple.())
     data Let_0123456789YSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789YSym0 arg)) (KindOf (Let_0123456789YSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789YSym0 arg) ~ KindOf (Let_0123456789YSym1 arg) =>
         Let_0123456789YSym0KindInference
     type instance Apply Let_0123456789YSym0 l = Let_0123456789YSym1 l
     type Let_0123456789Y x = (Apply SuccSym0 x :: Nat)
@@ -509,7 +509,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789YSym0KindInference GHC.Tuple.())
     data Let_0123456789YSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789YSym0 arg)) (KindOf (Let_0123456789YSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789YSym0 arg) ~ KindOf (Let_0123456789YSym1 arg) =>
         Let_0123456789YSym0KindInference
     type instance Apply Let_0123456789YSym0 l = Let_0123456789YSym1 l
     type Let_0123456789Y x = (Apply SuccSym0 ZeroSym0 :: Nat)
@@ -518,7 +518,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo14Sym0KindInference GHC.Tuple.())
     data Foo14Sym0 (l :: TyFun Nat (GHC.Tuple.(,) Nat Nat))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo14Sym0 arg)) (KindOf (Foo14Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo14Sym0 arg) ~ KindOf (Foo14Sym1 arg) =>
         Foo14Sym0KindInference
     type instance Apply Foo14Sym0 l = Foo14Sym1 l
     type Foo13_Sym1 (t :: a) = Foo13_ t
@@ -526,7 +526,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo13_Sym0KindInference GHC.Tuple.())
     data Foo13_Sym0 (l :: TyFun a a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo13_Sym0 arg)) (KindOf (Foo13_Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo13_Sym0 arg) ~ KindOf (Foo13_Sym1 arg) =>
         Foo13_Sym0KindInference
     type instance Apply Foo13_Sym0 l = Foo13_Sym1 l
     type Foo13Sym1 (t :: a) = Foo13 t
@@ -534,7 +534,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo13Sym0KindInference GHC.Tuple.())
     data Foo13Sym0 (l :: TyFun a a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo13Sym0 arg)) (KindOf (Foo13Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo13Sym0 arg) ~ KindOf (Foo13Sym1 arg) =>
         Foo13Sym0KindInference
     type instance Apply Foo13Sym0 l = Foo13Sym1 l
     type Foo12Sym1 (t :: Nat) = Foo12 t
@@ -542,7 +542,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo12Sym0KindInference GHC.Tuple.())
     data Foo12Sym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo12Sym0 arg)) (KindOf (Foo12Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo12Sym0 arg) ~ KindOf (Foo12Sym1 arg) =>
         Foo12Sym0KindInference
     type instance Apply Foo12Sym0 l = Foo12Sym1 l
     type Foo11Sym1 (t :: Nat) = Foo11 t
@@ -550,7 +550,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo11Sym0KindInference GHC.Tuple.())
     data Foo11Sym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo11Sym0 arg)) (KindOf (Foo11Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo11Sym0 arg) ~ KindOf (Foo11Sym1 arg) =>
         Foo11Sym0KindInference
     type instance Apply Foo11Sym0 l = Foo11Sym1 l
     type Foo10Sym1 (t :: Nat) = Foo10 t
@@ -558,7 +558,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo10Sym0KindInference GHC.Tuple.())
     data Foo10Sym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo10Sym0 arg)) (KindOf (Foo10Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo10Sym0 arg) ~ KindOf (Foo10Sym1 arg) =>
         Foo10Sym0KindInference
     type instance Apply Foo10Sym0 l = Foo10Sym1 l
     type Foo9Sym1 (t :: Nat) = Foo9 t
@@ -566,7 +566,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo9Sym0KindInference GHC.Tuple.())
     data Foo9Sym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo9Sym0 arg)) (KindOf (Foo9Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo9Sym0 arg) ~ KindOf (Foo9Sym1 arg) =>
         Foo9Sym0KindInference
     type instance Apply Foo9Sym0 l = Foo9Sym1 l
     type Foo8Sym1 (t :: Nat) = Foo8 t
@@ -574,7 +574,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo8Sym0KindInference GHC.Tuple.())
     data Foo8Sym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo8Sym0 arg)) (KindOf (Foo8Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo8Sym0 arg) ~ KindOf (Foo8Sym1 arg) =>
         Foo8Sym0KindInference
     type instance Apply Foo8Sym0 l = Foo8Sym1 l
     type Foo7Sym1 (t :: Nat) = Foo7 t
@@ -582,7 +582,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo7Sym0KindInference GHC.Tuple.())
     data Foo7Sym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo7Sym0 arg)) (KindOf (Foo7Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo7Sym0 arg) ~ KindOf (Foo7Sym1 arg) =>
         Foo7Sym0KindInference
     type instance Apply Foo7Sym0 l = Foo7Sym1 l
     type Foo6Sym1 (t :: Nat) = Foo6 t
@@ -590,7 +590,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo6Sym0KindInference GHC.Tuple.())
     data Foo6Sym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo6Sym0 arg)) (KindOf (Foo6Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo6Sym0 arg) ~ KindOf (Foo6Sym1 arg) =>
         Foo6Sym0KindInference
     type instance Apply Foo6Sym0 l = Foo6Sym1 l
     type Foo5Sym1 (t :: Nat) = Foo5 t
@@ -598,7 +598,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.())
     data Foo5Sym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo5Sym0 arg)) (KindOf (Foo5Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) =>
         Foo5Sym0KindInference
     type instance Apply Foo5Sym0 l = Foo5Sym1 l
     type Foo4Sym1 (t :: Nat) = Foo4 t
@@ -606,7 +606,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.())
     data Foo4Sym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo4Sym0 arg)) (KindOf (Foo4Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) =>
         Foo4Sym0KindInference
     type instance Apply Foo4Sym0 l = Foo4Sym1 l
     type Foo3Sym1 (t :: Nat) = Foo3 t
@@ -614,7 +614,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
     data Foo3Sym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo3Sym0 arg)) (KindOf (Foo3Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
         Foo3Sym0KindInference
     type instance Apply Foo3Sym0 l = Foo3Sym1 l
     type Foo2Sym0 = Foo2
@@ -623,7 +623,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
     data Foo1Sym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo1Sym0 arg)) (KindOf (Foo1Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
         Foo1Sym0KindInference
     type instance Apply Foo1Sym0 l = Foo1Sym1 l
     type family Foo14 (a :: Nat) :: GHC.Tuple.(,) Nat Nat where
@@ -672,8 +672,7 @@
     sFoo1 :: forall (t :: Nat). Sing t -> Sing (Apply Foo1Sym0 t)
     sFoo14 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo14Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo14Sym0 x)
           lambda x
             = let
                 sY :: Sing (Let_0123456789YSym1 x)
@@ -711,14 +710,12 @@
         in lambda sX
     sFoo13_ sY
       = let
-          lambda ::
-            forall y. (GHC.Types.~) t y => Sing y -> Sing (Apply Foo13_Sym0 y)
+          lambda :: forall y. t ~ y => Sing y -> Sing (Apply Foo13_Sym0 y)
           lambda y = y
         in lambda sY
     sFoo13 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo13Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo13Sym0 x)
           lambda x
             = let
                 sBar :: Sing (Let_0123456789BarSym1 x)
@@ -727,8 +724,7 @@
         in lambda sX
     sFoo12 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo12Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo12Sym0 x)
           lambda x
             = let
                 (%:+) ::
@@ -738,15 +734,14 @@
                 (%:+) SZero sM
                   = let
                       lambda ::
-                        forall m. ((GHC.Types.~) t ZeroSym0, (GHC.Types.~) t m) =>
+                        forall m. (t ~ ZeroSym0, t ~ m) =>
                         Sing m -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) ZeroSym0) m)
                       lambda m = m
                     in lambda sM
                 (%:+) (SSucc sN) sM
                   = let
                       lambda ::
-                        forall n m. ((GHC.Types.~) t (Apply SuccSym0 n),
-                                     (GHC.Types.~) t m) =>
+                        forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
                         Sing n
                         -> Sing m
                            -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 n)) m)
@@ -768,8 +763,7 @@
         in lambda sX
     sFoo11 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo11Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo11Sym0 x)
           lambda x
             = let
                 sZ :: Sing (Let_0123456789ZSym1 x)
@@ -781,15 +775,14 @@
                 (%:+) SZero sM
                   = let
                       lambda ::
-                        forall m. ((GHC.Types.~) t ZeroSym0, (GHC.Types.~) t m) =>
+                        forall m. (t ~ ZeroSym0, t ~ m) =>
                         Sing m -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) ZeroSym0) m)
                       lambda m = m
                     in lambda sM
                 (%:+) (SSucc sN) sM
                   = let
                       lambda ::
-                        forall n m. ((GHC.Types.~) t (Apply SuccSym0 n),
-                                     (GHC.Types.~) t m) =>
+                        forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
                         Sing n
                         -> Sing m
                            -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 n)) m)
@@ -810,8 +803,7 @@
         in lambda sX
     sFoo10 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo10Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo10Sym0 x)
           lambda x
             = let
                 (%:+) ::
@@ -821,15 +813,14 @@
                 (%:+) SZero sM
                   = let
                       lambda ::
-                        forall m. ((GHC.Types.~) t ZeroSym0, (GHC.Types.~) t m) =>
+                        forall m. (t ~ ZeroSym0, t ~ m) =>
                         Sing m -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) ZeroSym0) m)
                       lambda m = m
                     in lambda sM
                 (%:+) (SSucc sN) sM
                   = let
                       lambda ::
-                        forall n m. ((GHC.Types.~) t (Apply SuccSym0 n),
-                                     (GHC.Types.~) t m) =>
+                        forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
                         Sing n
                         -> Sing m
                            -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 n)) m)
@@ -850,15 +841,14 @@
         in lambda sX
     sFoo9 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo9Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo9Sym0 x)
           lambda x
             = let
                 sZ :: forall t. Sing t -> Sing (Apply (Let_0123456789ZSym1 x) t)
                 sZ sA_0123456789
                   = let
                       lambda ::
-                        forall a_0123456789. (GHC.Types.~) t a_0123456789 =>
+                        forall a_0123456789. t ~ a_0123456789 =>
                         Sing a_0123456789
                         -> Sing (Apply (Let_0123456789ZSym1 x) a_0123456789)
                       lambda a_0123456789
@@ -881,8 +871,7 @@
         in lambda sX
     sFoo8 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo8Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo8Sym0 x)
           lambda x
             = let
                 sZ :: Sing (Let_0123456789ZSym1 x)
@@ -902,8 +891,7 @@
         in lambda sX
     sFoo7 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo7Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo7Sym0 x)
           lambda x
             = let
                 sX :: Sing (Let_0123456789XSym1 x)
@@ -912,16 +900,14 @@
         in lambda sX
     sFoo6 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo6Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo6Sym0 x)
           lambda x
             = let
                 sF :: forall t. Sing t -> Sing (Apply (Let_0123456789FSym1 x) t)
                 sF sY
                   = let
                       lambda ::
-                        forall y. (GHC.Types.~) t y =>
-                        Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)
+                        forall y. t ~ y => Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)
                       lambda y = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y
                     in lambda sY in
               let
@@ -933,16 +919,14 @@
         in lambda sX
     sFoo5 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo5Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo5Sym0 x)
           lambda x
             = let
                 sF :: forall t. Sing t -> Sing (Apply (Let_0123456789FSym1 x) t)
                 sF sY
                   = let
                       lambda ::
-                        forall y. (GHC.Types.~) t y =>
-                        Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)
+                        forall y. t ~ y => Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)
                       lambda y
                         = let
                             sZ :: Sing (Let_0123456789ZSym2 x y)
@@ -954,16 +938,14 @@
         in lambda sX
     sFoo4 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo4Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo4Sym0 x)
           lambda x
             = let
                 sF :: forall t. Sing t -> Sing (Apply (Let_0123456789FSym1 x) t)
                 sF sY
                   = let
                       lambda ::
-                        forall y. (GHC.Types.~) t y =>
-                        Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)
+                        forall y. t ~ y => Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)
                       lambda y = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y
                     in lambda sY
               in
@@ -971,8 +953,7 @@
         in lambda sX
     sFoo3 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo3Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo3Sym0 x)
           lambda x
             = let
                 sY :: Sing (Let_0123456789YSym1 x)
@@ -988,8 +969,7 @@
         in sZ
     sFoo1 sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply Foo1Sym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo1Sym0 x)
           lambda x
             = let
                 sY :: Sing (Let_0123456789YSym1 x)
diff --git a/tests/compile-and-dump/Singletons/Maybe.ghc78.template b/tests/compile-and-dump/Singletons/Maybe.ghc78.template
--- a/tests/compile-and-dump/Singletons/Maybe.ghc78.template
+++ b/tests/compile-and-dump/Singletons/Maybe.ghc78.template
@@ -21,12 +21,12 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) JustSym0KindInference GHC.Tuple.())
     data JustSym0 (l :: TyFun a (Maybe a))
-      = forall arg. (GHC.Types.~) (KindOf (Apply JustSym0 arg)) (KindOf (JustSym1 arg)) =>
+      = forall arg. KindOf (Apply JustSym0 arg) ~ KindOf (JustSym1 arg) =>
         JustSym0KindInference
     type instance Apply JustSym0 l = JustSym1 l
     data instance Sing (z :: Maybe a)
-      = (GHC.Types.~) z Nothing => SNothing |
-        forall (n :: a). (GHC.Types.~) z (Just n) => SJust (Sing n)
+      = z ~ Nothing => SNothing |
+        forall (n :: a). z ~ Just n => SJust (Sing n)
     type SMaybe (z :: Maybe a) = Sing z
     instance SingKind (KProxy :: KProxy a) =>
              SingKind (KProxy :: KProxy (Maybe a)) where
diff --git a/tests/compile-and-dump/Singletons/Nat.ghc78.template b/tests/compile-and-dump/Singletons/Nat.ghc78.template
--- a/tests/compile-and-dump/Singletons/Nat.ghc78.template
+++ b/tests/compile-and-dump/Singletons/Nat.ghc78.template
@@ -35,7 +35,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
     data SuccSym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply SuccSym0 arg)) (KindOf (SuccSym1 arg)) =>
+      = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) =>
         SuccSym0KindInference
     type instance Apply SuccSym0 l = SuccSym1 l
     type PredSym1 (t :: Nat) = Pred t
@@ -43,7 +43,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) PredSym0KindInference GHC.Tuple.())
     data PredSym0 (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply PredSym0 arg)) (KindOf (PredSym1 arg)) =>
+      = forall arg. KindOf (Apply PredSym0 arg) ~ KindOf (PredSym1 arg) =>
         PredSym0KindInference
     type instance Apply PredSym0 l = PredSym1 l
     type PlusSym2 (t :: Nat) (t :: Nat) = Plus t t
@@ -51,14 +51,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) PlusSym1KindInference GHC.Tuple.())
     data PlusSym1 (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (PlusSym1 l) arg)) (KindOf (PlusSym2 l arg)) =>
+      = forall arg. KindOf (Apply (PlusSym1 l) arg) ~ KindOf (PlusSym2 l arg) =>
         PlusSym1KindInference
     type instance Apply (PlusSym1 l) l = PlusSym2 l l
     instance SuppressUnusedWarnings PlusSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) PlusSym0KindInference GHC.Tuple.())
     data PlusSym0 (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply PlusSym0 arg)) (KindOf (PlusSym1 arg)) =>
+      = forall arg. KindOf (Apply PlusSym0 arg) ~ KindOf (PlusSym1 arg) =>
         PlusSym0KindInference
     type instance Apply PlusSym0 l = PlusSym1 l
     type family Pred (a :: Nat) :: Nat where
@@ -73,29 +73,27 @@
       Sing t -> Sing t -> Sing (Apply (Apply PlusSym0 t) t)
     sPred SZero
       = let
-          lambda ::
-            (GHC.Types.~) t ZeroSym0 => Sing (Apply PredSym0 ZeroSym0)
+          lambda :: t ~ ZeroSym0 => Sing (Apply PredSym0 ZeroSym0)
           lambda = SZero
         in lambda
     sPred (SSucc sN)
       = let
           lambda ::
-            forall n. (GHC.Types.~) t (Apply SuccSym0 n) =>
+            forall n. t ~ Apply SuccSym0 n =>
             Sing n -> Sing (Apply PredSym0 (Apply SuccSym0 n))
           lambda n = n
         in lambda sN
     sPlus SZero sM
       = let
           lambda ::
-            forall m. ((GHC.Types.~) t ZeroSym0, (GHC.Types.~) t m) =>
+            forall m. (t ~ ZeroSym0, t ~ m) =>
             Sing m -> Sing (Apply (Apply PlusSym0 ZeroSym0) m)
           lambda m = m
         in lambda sM
     sPlus (SSucc sN) sM
       = let
           lambda ::
-            forall n m. ((GHC.Types.~) t (Apply SuccSym0 n),
-                         (GHC.Types.~) t m) =>
+            forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
             Sing n
             -> Sing m -> Sing (Apply (Apply PlusSym0 (Apply SuccSym0 n)) m)
           lambda n m
@@ -105,8 +103,8 @@
                    (applySing (singFun2 (Proxy :: Proxy PlusSym0) sPlus) n) m)
         in lambda sN sM
     data instance Sing (z :: Nat)
-      = (GHC.Types.~) z Zero => SZero |
-        forall (n :: Nat). (GHC.Types.~) z (Succ n) => SSucc (Sing n)
+      = z ~ Zero => SZero |
+        forall (n :: Nat). z ~ Succ n => SSucc (Sing n)
     type SNat (z :: Nat) = Sing z
     instance SingKind (KProxy :: KProxy Nat) where
       type DemoteRep (KProxy :: KProxy Nat) = Nat
diff --git a/tests/compile-and-dump/Singletons/Operators.ghc78.template b/tests/compile-and-dump/Singletons/Operators.ghc78.template
--- a/tests/compile-and-dump/Singletons/Operators.ghc78.template
+++ b/tests/compile-and-dump/Singletons/Operators.ghc78.template
@@ -26,14 +26,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) (:+:$$###) GHC.Tuple.())
     data (:+:$$) (l :: Foo) (l :: TyFun Foo Foo)
-      = forall arg. (GHC.Types.~) (KindOf (Apply ((:+:$$) l) arg)) (KindOf ((:+:$$$) l arg)) =>
+      = forall arg. 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 Foo (TyFun Foo Foo -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (:+:$) arg)) (KindOf ((:+:$$) arg)) =>
+      = forall arg. KindOf (Apply (:+:$) arg) ~ KindOf ((:+:$$) arg) =>
         (:+:$###)
     type instance Apply (:+:$) l = (:+:$$) l
     type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t
@@ -41,14 +41,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
     data (:+$$) (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply ((:+$$) l) arg)) (KindOf ((:+$$$) l arg)) =>
+      = forall arg. 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 Nat (TyFun Nat Nat -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (:+$) arg)) (KindOf ((:+$$) arg)) =>
+      = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) =>
         (:+$###)
     type instance Apply (:+$) l = (:+$$) l
     type ChildSym1 (t :: Foo) = Child t
@@ -56,7 +56,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) ChildSym0KindInference GHC.Tuple.())
     data ChildSym0 (l :: TyFun Foo Foo)
-      = forall arg. (GHC.Types.~) (KindOf (Apply ChildSym0 arg)) (KindOf (ChildSym1 arg)) =>
+      = forall arg. KindOf (Apply ChildSym0 arg) ~ KindOf (ChildSym1 arg) =>
         ChildSym0KindInference
     type instance Apply ChildSym0 l = ChildSym1 l
     type family (:+) (a :: Nat) (a :: Nat) :: Nat where
@@ -72,15 +72,14 @@
     (%:+) SZero sM
       = let
           lambda ::
-            forall m. ((GHC.Types.~) t ZeroSym0, (GHC.Types.~) t m) =>
+            forall m. (t ~ ZeroSym0, t ~ m) =>
             Sing m -> Sing (Apply (Apply (:+$) ZeroSym0) m)
           lambda m = m
         in lambda sM
     (%:+) (SSucc sN) sM
       = let
           lambda ::
-            forall n m. ((GHC.Types.~) t (Apply SuccSym0 n),
-                         (GHC.Types.~) t m) =>
+            forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
             Sing n -> Sing m -> Sing (Apply (Apply (:+$) (Apply SuccSym0 n)) m)
           lambda n m
             = applySing
@@ -89,20 +88,19 @@
         in lambda sN sM
     sChild SFLeaf
       = let
-          lambda ::
-            (GHC.Types.~) t FLeafSym0 => Sing (Apply ChildSym0 FLeafSym0)
+          lambda :: t ~ FLeafSym0 => Sing (Apply ChildSym0 FLeafSym0)
           lambda = SFLeaf
         in lambda
     sChild ((:%+:) sA _)
       = let
           lambda ::
-            forall a wild. (GHC.Types.~) t (Apply (Apply (:+:$) a) wild) =>
+            forall a wild. t ~ Apply (Apply (:+:$) a) wild =>
             Sing a -> Sing (Apply ChildSym0 (Apply (Apply (:+:$) a) wild))
           lambda a = a
         in lambda sA
     data instance Sing (z :: Foo)
-      = (GHC.Types.~) z FLeaf => SFLeaf |
-        forall (n :: Foo) (n :: Foo). (GHC.Types.~) z ((:+:) n n) =>
+      = z ~ FLeaf => SFLeaf |
+        forall (n :: Foo) (n :: Foo). z ~ (:+:) n n =>
         (:%+:) (Sing n) (Sing n)
     type SFoo (z :: Foo) = Sing z
     instance SingKind (KProxy :: KProxy Foo) where
diff --git a/tests/compile-and-dump/Singletons/PatternMatching.ghc78.template b/tests/compile-and-dump/Singletons/PatternMatching.ghc78.template
--- a/tests/compile-and-dump/Singletons/PatternMatching.ghc78.template
+++ b/tests/compile-and-dump/Singletons/PatternMatching.ghc78.template
@@ -22,14 +22,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.())
     data PairSym1 (l :: a) (l :: TyFun b (Pair a b))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (PairSym1 l) arg)) (KindOf (PairSym2 l arg)) =>
+      = forall arg. KindOf (Apply (PairSym1 l) arg) ~ KindOf (PairSym2 l arg) =>
         PairSym1KindInference
     type instance Apply (PairSym1 l) l = PairSym2 l l
     instance SuppressUnusedWarnings PairSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.())
     data PairSym0 (l :: TyFun a (TyFun b (Pair a b) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply PairSym0 arg)) (KindOf (PairSym1 arg)) =>
+      = forall arg. KindOf (Apply PairSym0 arg) ~ KindOf (PairSym1 arg) =>
         PairSym0KindInference
     type instance Apply PairSym0 l = PairSym1 l
     type AListSym0 = AList
@@ -86,8 +86,7 @@
           (applySing
              (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) SNil)
     data instance Sing (z :: Pair a b)
-      = forall (n :: a) (n :: b). (GHC.Types.~) z (Pair n n) =>
-        SPair (Sing n) (Sing n)
+      = forall (n :: a) (n :: b). z ~ Pair n n => SPair (Sing n) (Sing n)
     type SPair (z :: Pair a b) = Sing z
     instance (SingKind (KProxy :: KProxy a),
               SingKind (KProxy :: KProxy b)) =>
@@ -132,14 +131,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789TSym1KindInference GHC.Tuple.())
     data Let_0123456789TSym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789TSym1 l) arg)) (KindOf (Let_0123456789TSym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789TSym1 l) arg) ~ KindOf (Let_0123456789TSym2 l arg) =>
         Let_0123456789TSym1KindInference
     type instance Apply (Let_0123456789TSym1 l) l = Let_0123456789TSym2 l l
     instance SuppressUnusedWarnings Let_0123456789TSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Let_0123456789TSym0KindInference GHC.Tuple.())
     data Let_0123456789TSym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789TSym0 arg)) (KindOf (Let_0123456789TSym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789TSym0 arg) ~ KindOf (Let_0123456789TSym1 arg) =>
         Let_0123456789TSym0KindInference
     type instance Apply Let_0123456789TSym0 l = Let_0123456789TSym1 l
     type Let_0123456789T x y = Apply (Apply Tuple2Sym0 x) y
@@ -151,7 +150,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
         Let_0123456789Scrutinee_0123456789Sym1KindInference
     type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
     instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
@@ -160,7 +159,7 @@
             (GHC.Tuple.(,)
                Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
     data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg)) (KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
         Let_0123456789Scrutinee_0123456789Sym0KindInference
     type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
     type Let_0123456789Scrutinee_0123456789 x y =
@@ -175,7 +174,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym4KindInference GHC.Tuple.())
     data Lambda_0123456789Sym4 l l l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym4 l l l l) arg)) (KindOf (Lambda_0123456789Sym5 l l l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym4 l l l l) arg) ~ KindOf (Lambda_0123456789Sym5 l l l l arg) =>
         Lambda_0123456789Sym4KindInference
     type instance Apply (Lambda_0123456789Sym4 l l l l) l = Lambda_0123456789Sym5 l l l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
@@ -183,7 +182,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
     data Lambda_0123456789Sym3 l l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym3 l l l) arg)) (KindOf (Lambda_0123456789Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
         Lambda_0123456789Sym3KindInference
     type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
@@ -191,7 +190,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -199,7 +198,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -207,7 +206,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Case_0123456789 x y t where
@@ -222,7 +221,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
     data Lambda_0123456789Sym2 l l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym2 l l) arg)) (KindOf (Lambda_0123456789Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
         Lambda_0123456789Sym2KindInference
     type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
@@ -230,7 +229,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
     data Lambda_0123456789Sym1 l l
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Lambda_0123456789Sym1 l) arg)) (KindOf (Lambda_0123456789Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
         Lambda_0123456789Sym1KindInference
     type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
     instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
@@ -238,7 +237,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type family Case_0123456789 t where
@@ -266,7 +265,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
     data Foo2Sym0 (l :: TyFun (GHC.Tuple.(,) a b) a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo2Sym0 arg)) (KindOf (Foo2Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
         Foo2Sym0KindInference
     type instance Apply Foo2Sym0 l = Foo2Sym1 l
     type Foo1Sym1 (t :: GHC.Tuple.(,) a b) = Foo1 t
@@ -274,7 +273,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
     data Foo1Sym0 (l :: TyFun (GHC.Tuple.(,) a b) a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Foo1Sym0 arg)) (KindOf (Foo1Sym1 arg)) =>
+      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
         Foo1Sym0KindInference
     type instance Apply Foo1Sym0 l = Foo1Sym1 l
     type LszSym0 = Lsz
@@ -330,7 +329,7 @@
     sFoo2 (STuple2 sX sY)
       = let
           lambda ::
-            forall x y. (GHC.Types.~) t (Apply (Apply Tuple2Sym0 x) y) =>
+            forall x y. t ~ Apply (Apply Tuple2Sym0 x) y =>
             Sing x
             -> Sing y -> Sing (Apply Foo2Sym0 (Apply (Apply Tuple2Sym0 x) y))
           lambda x y
@@ -378,7 +377,7 @@
     sFoo1 (STuple2 sX sY)
       = let
           lambda ::
-            forall x y. (GHC.Types.~) t (Apply (Apply Tuple2Sym0 x) y) =>
+            forall x y. t ~ Apply (Apply Tuple2Sym0 x) y =>
             Sing x
             -> Sing y -> Sing (Apply Foo1Sym0 (Apply (Apply Tuple2Sym0 x) y))
           lambda x y
diff --git a/tests/compile-and-dump/Singletons/Records.ghc78.template b/tests/compile-and-dump/Singletons/Records.ghc78.template
--- a/tests/compile-and-dump/Singletons/Records.ghc78.template
+++ b/tests/compile-and-dump/Singletons/Records.ghc78.template
@@ -9,7 +9,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Field1Sym0KindInference GHC.Tuple.())
     data Field1Sym0 (l :: TyFun (Record a) a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Field1Sym0 arg)) (KindOf (Field1Sym1 arg)) =>
+      = forall arg. KindOf (Apply Field1Sym0 arg) ~ KindOf (Field1Sym1 arg) =>
         Field1Sym0KindInference
     type instance Apply Field1Sym0 l = Field1Sym1 l
     type Field2Sym1 (t :: Record a) = Field2 t
@@ -17,7 +17,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Field2Sym0KindInference GHC.Tuple.())
     data Field2Sym0 (l :: TyFun (Record a) Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply Field2Sym0 arg)) (KindOf (Field2Sym1 arg)) =>
+      = forall arg. KindOf (Apply Field2Sym0 arg) ~ KindOf (Field2Sym1 arg) =>
         Field2Sym0KindInference
     type instance Apply Field2Sym0 l = Field2Sym1 l
     type family Field1 (a :: Record a) :: a where
@@ -29,18 +29,18 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) MkRecordSym1KindInference GHC.Tuple.())
     data MkRecordSym1 (l :: a) (l :: TyFun Bool (Record a))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (MkRecordSym1 l) arg)) (KindOf (MkRecordSym2 l arg)) =>
+      = forall arg. KindOf (Apply (MkRecordSym1 l) arg) ~ KindOf (MkRecordSym2 l arg) =>
         MkRecordSym1KindInference
     type instance Apply (MkRecordSym1 l) l = MkRecordSym2 l l
     instance SuppressUnusedWarnings MkRecordSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) MkRecordSym0KindInference GHC.Tuple.())
     data MkRecordSym0 (l :: TyFun a (TyFun Bool (Record a) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply MkRecordSym0 arg)) (KindOf (MkRecordSym1 arg)) =>
+      = forall arg. KindOf (Apply MkRecordSym0 arg) ~ KindOf (MkRecordSym1 arg) =>
         MkRecordSym0KindInference
     type instance Apply MkRecordSym0 l = MkRecordSym1 l
     data instance Sing (z :: Record a)
-      = forall (n :: a) (n :: Bool). (GHC.Types.~) z (MkRecord n n) =>
+      = forall (n :: a) (n :: Bool). z ~ MkRecord n n =>
         SMkRecord {sField1 :: Sing n, sField2 :: Sing n}
     type SRecord (z :: Record a) = Sing z
     instance SingKind (KProxy :: KProxy a) =>
diff --git a/tests/compile-and-dump/Singletons/ReturnFunc.ghc78.template b/tests/compile-and-dump/Singletons/ReturnFunc.ghc78.template
--- a/tests/compile-and-dump/Singletons/ReturnFunc.ghc78.template
+++ b/tests/compile-and-dump/Singletons/ReturnFunc.ghc78.template
@@ -19,7 +19,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) IdSym0KindInference GHC.Tuple.())
     data IdSym0 (l :: TyFun a a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply IdSym0 arg)) (KindOf (IdSym1 arg)) =>
+      = forall arg. KindOf (Apply IdSym0 arg) ~ KindOf (IdSym1 arg) =>
         IdSym0KindInference
     type instance Apply IdSym0 l = IdSym1 l
     type IdFooSym2 (t :: c) (t :: a) = IdFoo t t
@@ -27,14 +27,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) IdFooSym1KindInference GHC.Tuple.())
     data IdFooSym1 (l :: c) (l :: TyFun a a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (IdFooSym1 l) arg)) (KindOf (IdFooSym2 l arg)) =>
+      = forall arg. KindOf (Apply (IdFooSym1 l) arg) ~ KindOf (IdFooSym2 l arg) =>
         IdFooSym1KindInference
     type instance Apply (IdFooSym1 l) l = IdFooSym2 l l
     instance SuppressUnusedWarnings IdFooSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) IdFooSym0KindInference GHC.Tuple.())
     data IdFooSym0 (l :: TyFun c (TyFun a a -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply IdFooSym0 arg)) (KindOf (IdFooSym1 arg)) =>
+      = forall arg. KindOf (Apply IdFooSym0 arg) ~ KindOf (IdFooSym1 arg) =>
         IdFooSym0KindInference
     type instance Apply IdFooSym0 l = IdFooSym1 l
     type ReturnFuncSym2 (t :: Nat) (t :: Nat) = ReturnFunc t t
@@ -42,14 +42,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) ReturnFuncSym1KindInference GHC.Tuple.())
     data ReturnFuncSym1 (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (ReturnFuncSym1 l) arg)) (KindOf (ReturnFuncSym2 l arg)) =>
+      = forall arg. KindOf (Apply (ReturnFuncSym1 l) arg) ~ KindOf (ReturnFuncSym2 l arg) =>
         ReturnFuncSym1KindInference
     type instance Apply (ReturnFuncSym1 l) l = ReturnFuncSym2 l l
     instance SuppressUnusedWarnings ReturnFuncSym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) ReturnFuncSym0KindInference GHC.Tuple.())
     data ReturnFuncSym0 (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply ReturnFuncSym0 arg)) (KindOf (ReturnFuncSym1 arg)) =>
+      = forall arg. KindOf (Apply ReturnFuncSym0 arg) ~ KindOf (ReturnFuncSym1 arg) =>
         ReturnFuncSym0KindInference
     type instance Apply ReturnFuncSym0 l = ReturnFuncSym1 l
     type family Id (a :: a) :: a where
@@ -67,15 +67,13 @@
       Sing t -> Sing t -> Sing (Apply (Apply ReturnFuncSym0 t) t)
     sId sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply IdSym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply IdSym0 x)
           lambda x = x
         in lambda sX
     sIdFoo _ sA_0123456789
       = let
           lambda ::
-            forall a_0123456789 wild. ((GHC.Types.~) t wild,
-                                       (GHC.Types.~) t a_0123456789) =>
+            forall a_0123456789 wild. (t ~ wild, t ~ a_0123456789) =>
             Sing a_0123456789
             -> Sing (Apply (Apply IdFooSym0 wild) a_0123456789)
           lambda a_0123456789
@@ -84,8 +82,7 @@
     sReturnFunc _ sA_0123456789
       = let
           lambda ::
-            forall a_0123456789 wild. ((GHC.Types.~) t wild,
-                                       (GHC.Types.~) t a_0123456789) =>
+            forall a_0123456789 wild. (t ~ wild, t ~ a_0123456789) =>
             Sing a_0123456789
             -> Sing (Apply (Apply ReturnFuncSym0 wild) a_0123456789)
           lambda a_0123456789
diff --git a/tests/compile-and-dump/Singletons/Sections.ghc78.template b/tests/compile-and-dump/Singletons/Sections.ghc78.template
--- a/tests/compile-and-dump/Singletons/Sections.ghc78.template
+++ b/tests/compile-and-dump/Singletons/Sections.ghc78.template
@@ -28,7 +28,7 @@
         = snd
             (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
     data Lambda_0123456789Sym0 l
-      = forall arg. (GHC.Types.~) (KindOf (Apply Lambda_0123456789Sym0 arg)) (KindOf (Lambda_0123456789Sym1 arg)) =>
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
     type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t
@@ -36,14 +36,14 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
     data (:+$$) (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. (GHC.Types.~) (KindOf (Apply ((:+$$) l) arg)) (KindOf ((:+$$$) l arg)) =>
+      = forall arg. 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 Nat (TyFun Nat Nat -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (:+$) arg)) (KindOf ((:+$$) arg)) =>
+      = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) =>
         (:+$###)
     type instance Apply (:+$) l = (:+$$) l
     type Foo1Sym0 = Foo1
@@ -67,15 +67,14 @@
     (%:+) SZero sM
       = let
           lambda ::
-            forall m. ((GHC.Types.~) t ZeroSym0, (GHC.Types.~) t m) =>
+            forall m. (t ~ ZeroSym0, t ~ m) =>
             Sing m -> Sing (Apply (Apply (:+$) ZeroSym0) m)
           lambda m = m
         in lambda sM
     (%:+) (SSucc sN) sM
       = let
           lambda ::
-            forall n m. ((GHC.Types.~) t (Apply SuccSym0 n),
-                         (GHC.Types.~) t m) =>
+            forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
             Sing n -> Sing m -> Sing (Apply (Apply (:+$) (Apply SuccSym0 n)) m)
           lambda n m
             = applySing
diff --git a/tests/compile-and-dump/Singletons/Star.ghc78.template b/tests/compile-and-dump/Singletons/Star.ghc78.template
--- a/tests/compile-and-dump/Singletons/Star.ghc78.template
+++ b/tests/compile-and-dump/Singletons/Star.ghc78.template
@@ -52,7 +52,7 @@
       Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) MaybeSym0KindInference GHC.Tuple.())
     data MaybeSym0 (l :: TyFun * *)
-      = forall arg. (GHC.Types.~) (KindOf (Apply MaybeSym0 arg)) (KindOf (MaybeSym1 arg)) =>
+      = forall arg. KindOf (Apply MaybeSym0 arg) ~ KindOf (MaybeSym1 arg) =>
         MaybeSym0KindInference
     type instance Apply MaybeSym0 l = MaybeSym1 l
     type VecSym2 (t :: *) (t :: Nat) = Vec t t
@@ -60,23 +60,22 @@
       Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) VecSym1KindInference GHC.Tuple.())
     data VecSym1 (l :: *) (l :: TyFun Nat *)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (VecSym1 l) arg)) (KindOf (VecSym2 l arg)) =>
+      = forall arg. KindOf (Apply (VecSym1 l) arg) ~ KindOf (VecSym2 l arg) =>
         VecSym1KindInference
     type instance Apply (VecSym1 l) l = VecSym2 l l
     instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings VecSym0 where
       Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) VecSym0KindInference GHC.Tuple.())
     data VecSym0 (l :: TyFun * (TyFun Nat * -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply VecSym0 arg)) (KindOf (VecSym1 arg)) =>
+      = forall arg. KindOf (Apply VecSym0 arg) ~ KindOf (VecSym1 arg) =>
         VecSym0KindInference
     type instance Apply VecSym0 l = VecSym1 l
     data instance Sing (z :: *)
-      = (GHC.Types.~) z Nat => SNat |
-        (GHC.Types.~) z Int => SInt |
-        (GHC.Types.~) z String => SString |
-        forall (n :: *). (GHC.Types.~) z (Maybe n) => SMaybe (Sing n) |
-        forall (n :: *) (n :: Nat). (GHC.Types.~) z (Vec n n) =>
-        SVec (Sing n) (Sing n)
+      = z ~ Nat => SNat |
+        z ~ Int => SInt |
+        z ~ String => SString |
+        forall (n :: *). z ~ Maybe n => SMaybe (Sing n) |
+        forall (n :: *) (n :: Nat). z ~ Vec n n => SVec (Sing n) (Sing n)
     type SRep (z :: *) = Sing z
     instance SingKind (KProxy :: KProxy *) where
       type DemoteRep (KProxy :: KProxy *) = Rep
diff --git a/tests/compile-and-dump/Singletons/T29.ghc78.template b/tests/compile-and-dump/Singletons/T29.ghc78.template
--- a/tests/compile-and-dump/Singletons/T29.ghc78.template
+++ b/tests/compile-and-dump/Singletons/T29.ghc78.template
@@ -23,7 +23,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) BanSym0KindInference GHC.Tuple.())
     data BanSym0 (l :: TyFun Bool Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply BanSym0 arg)) (KindOf (BanSym1 arg)) =>
+      = forall arg. KindOf (Apply BanSym0 arg) ~ KindOf (BanSym1 arg) =>
         BanSym0KindInference
     type instance Apply BanSym0 l = BanSym1 l
     type BazSym1 (t :: Bool) = Baz t
@@ -31,7 +31,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) BazSym0KindInference GHC.Tuple.())
     data BazSym0 (l :: TyFun Bool Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply BazSym0 arg)) (KindOf (BazSym1 arg)) =>
+      = forall arg. KindOf (Apply BazSym0 arg) ~ KindOf (BazSym1 arg) =>
         BazSym0KindInference
     type instance Apply BazSym0 l = BazSym1 l
     type BarSym1 (t :: Bool) = Bar t
@@ -39,7 +39,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
     data BarSym0 (l :: TyFun Bool Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply BarSym0 arg)) (KindOf (BarSym1 arg)) =>
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
         BarSym0KindInference
     type instance Apply BarSym0 l = BarSym1 l
     type FooSym1 (t :: Bool) = Foo t
@@ -47,7 +47,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
     data FooSym0 (l :: TyFun Bool Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply FooSym0 arg)) (KindOf (FooSym1 arg)) =>
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
         FooSym0KindInference
     type instance Apply FooSym0 l = FooSym1 l
     type family Ban (a :: Bool) :: Bool where
@@ -64,8 +64,7 @@
     sFoo :: forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t)
     sBan sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply BanSym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply BanSym0 x)
           lambda x
             = applySing
                 (applySing
@@ -83,8 +82,7 @@
         in lambda sX
     sBaz sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply BazSym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply BazSym0 x)
           lambda x
             = applySing
                 (applySing
@@ -94,8 +92,7 @@
         in lambda sX
     sBar sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply BarSym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply BarSym0 x)
           lambda x
             = applySing
                 (applySing
@@ -113,8 +110,7 @@
         in lambda sX
     sFoo sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply FooSym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply FooSym0 x)
           lambda x
             = applySing
                 (applySing
diff --git a/tests/compile-and-dump/Singletons/T33.ghc78.template b/tests/compile-and-dump/Singletons/T33.ghc78.template
--- a/tests/compile-and-dump/Singletons/T33.ghc78.template
+++ b/tests/compile-and-dump/Singletons/T33.ghc78.template
@@ -11,7 +11,7 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
     data FooSym0 (l :: TyFun (GHC.Tuple.(,) Bool Bool) GHC.Tuple.())
-      = forall arg. (GHC.Types.~) (KindOf (Apply FooSym0 arg)) (KindOf (FooSym1 arg)) =>
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
         FooSym0KindInference
     type instance Apply FooSym0 l = FooSym1 l
     type family Foo (a :: GHC.Tuple.(,) Bool Bool) :: GHC.Tuple.() where
@@ -22,8 +22,7 @@
     sFoo (STuple2 _ _)
       = let
           lambda ::
-            forall wild
-                   wild. (GHC.Types.~) t (Apply (Apply Tuple2Sym0 wild) wild) =>
+            forall wild wild. t ~ Apply (Apply Tuple2Sym0 wild) wild =>
             Sing (Apply FooSym0 (Apply (Apply Tuple2Sym0 wild) wild))
           lambda = STuple0
         in lambda
diff --git a/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc78.template b/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc78.template
--- a/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc78.template
+++ b/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc78.template
@@ -13,18 +13,18 @@
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) BarSym1KindInference GHC.Tuple.())
     data BarSym1 (l :: Bool) (l :: TyFun Bool Foo)
-      = forall arg. (GHC.Types.~) (KindOf (Apply (BarSym1 l) arg)) (KindOf (BarSym2 l arg)) =>
+      = forall arg. KindOf (Apply (BarSym1 l) arg) ~ KindOf (BarSym2 l arg) =>
         BarSym1KindInference
     type instance Apply (BarSym1 l) l = BarSym2 l l
     instance SuppressUnusedWarnings BarSym0 where
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
     data BarSym0 (l :: TyFun Bool (TyFun Bool Foo -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply BarSym0 arg)) (KindOf (BarSym1 arg)) =>
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
         BarSym0KindInference
     type instance Apply BarSym0 l = BarSym1 l
     data instance Sing (z :: Bool)
-      = (GHC.Types.~) z False => SFalse | (GHC.Types.~) z True => STrue
+      = z ~ False => SFalse | z ~ True => STrue
     type SBool (z :: Bool) = Sing z
     instance SingKind (KProxy :: KProxy Bool) where
       type DemoteRep (KProxy :: KProxy Bool) = Bool
@@ -33,7 +33,7 @@
       toSing False = SomeSing SFalse
       toSing True = SomeSing STrue
     data instance Sing (z :: Foo)
-      = forall (n :: Bool) (n :: Bool). (GHC.Types.~) z (Bar n n) =>
+      = forall (n :: Bool) (n :: Bool). z ~ Bar n n =>
         SBar (Sing n) (Sing n)
     type SFoo (z :: Foo) = Sing z
     instance SingKind (KProxy :: KProxy Foo) where
@@ -79,7 +79,7 @@
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) NotSym0KindInference GHC.Tuple.())
     data NotSym0 (l :: TyFun Bool Bool)
-      = forall arg. (GHC.Types.~) (KindOf (Apply NotSym0 arg)) (KindOf (NotSym1 arg)) =>
+      = forall arg. KindOf (Apply NotSym0 arg) ~ KindOf (NotSym1 arg) =>
         NotSym0KindInference
     type instance Apply NotSym0 l = NotSym1 l
     type IdSym1 (t :: a) = Id t
@@ -87,7 +87,7 @@
       suppressUnusedWarnings _
         = Data.Tuple.snd (GHC.Tuple.(,) IdSym0KindInference GHC.Tuple.())
     data IdSym0 (l :: TyFun a a)
-      = forall arg. (GHC.Types.~) (KindOf (Apply IdSym0 arg)) (KindOf (IdSym1 arg)) =>
+      = forall arg. KindOf (Apply IdSym0 arg) ~ KindOf (IdSym1 arg) =>
         IdSym0KindInference
     type instance Apply IdSym0 l = IdSym1 l
     type OtherwiseSym0 = Otherwise
@@ -105,19 +105,17 @@
     sFalse_ = SFalse
     sNot STrue
       = let
-          lambda :: (GHC.Types.~) t TrueSym0 => Sing (Apply NotSym0 TrueSym0)
+          lambda :: t ~ TrueSym0 => Sing (Apply NotSym0 TrueSym0)
           lambda = SFalse
         in lambda
     sNot SFalse
       = let
-          lambda ::
-            (GHC.Types.~) t FalseSym0 => Sing (Apply NotSym0 FalseSym0)
+          lambda :: t ~ FalseSym0 => Sing (Apply NotSym0 FalseSym0)
           lambda = STrue
         in lambda
     sId sX
       = let
-          lambda ::
-            forall x. (GHC.Types.~) t x => Sing x -> Sing (Apply IdSym0 x)
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply IdSym0 x)
           lambda x = x
         in lambda sX
     sOtherwise = STrue
diff --git a/tests/compile-and-dump/Singletons/Tuples.ghc78.template b/tests/compile-and-dump/Singletons/Tuples.ghc78.template
--- a/tests/compile-and-dump/Singletons/Tuples.ghc78.template
+++ b/tests/compile-and-dump/Singletons/Tuples.ghc78.template
@@ -5,7 +5,7 @@
     Singletons/Tuples.hs:(0,0)-(0,0)
     type Tuple0Sym0 = GHC.Tuple.()
     data instance Sing (z :: GHC.Tuple.())
-      = (GHC.Types.~) z GHC.Tuple.() => STuple0
+      = z ~ GHC.Tuple.() => STuple0
     type STuple0 (z :: GHC.Tuple.()) = Sing z
     instance SingKind (KProxy :: KProxy GHC.Tuple.()) where
       type DemoteRep (KProxy :: KProxy GHC.Tuple.()) = GHC.Tuple.()
@@ -18,18 +18,18 @@
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Tuple2Sym1KindInference GHC.Tuple.())
     data Tuple2Sym1 (l :: a) (l :: TyFun b (GHC.Tuple.(,) a b))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple2Sym1 l) arg)) (KindOf (Tuple2Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Tuple2Sym1 l) arg) ~ KindOf (Tuple2Sym2 l arg) =>
         Tuple2Sym1KindInference
     type instance Apply (Tuple2Sym1 l) l = Tuple2Sym2 l l
     instance SuppressUnusedWarnings Tuple2Sym0 where
       suppressUnusedWarnings _
         = snd (GHC.Tuple.(,) Tuple2Sym0KindInference GHC.Tuple.())
     data Tuple2Sym0 (l :: TyFun a (TyFun b (GHC.Tuple.(,) a b) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Tuple2Sym0 arg)) (KindOf (Tuple2Sym1 arg)) =>
+      = forall arg. KindOf (Apply Tuple2Sym0 arg) ~ KindOf (Tuple2Sym1 arg) =>
         Tuple2Sym0KindInference
     type instance Apply Tuple2Sym0 l = Tuple2Sym1 l
     data instance Sing (z :: GHC.Tuple.(,) a b)
-      = forall (n :: a) (n :: b). (GHC.Types.~) z (GHC.Tuple.(,) n n) =>
+      = forall (n :: a) (n :: b). z ~ GHC.Tuple.(,) n n =>
         STuple2 (Sing n) (Sing n)
     type STuple2 (z :: GHC.Tuple.(,) a b) = Sing z
     instance (SingKind (KProxy :: KProxy a),
@@ -54,7 +54,7 @@
     data Tuple3Sym2 (l :: a)
                     (l :: b)
                     (l :: TyFun c (GHC.Tuple.(,,) a b c))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple3Sym2 l l) arg)) (KindOf (Tuple3Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple3Sym2 l l) arg) ~ KindOf (Tuple3Sym3 l l arg) =>
         Tuple3Sym2KindInference
     type instance Apply (Tuple3Sym2 l l) l = Tuple3Sym3 l l l
     instance SuppressUnusedWarnings Tuple3Sym1 where
@@ -62,7 +62,7 @@
         = snd (GHC.Tuple.(,) Tuple3Sym1KindInference GHC.Tuple.())
     data Tuple3Sym1 (l :: a)
                     (l :: TyFun b (TyFun c (GHC.Tuple.(,,) a b c) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple3Sym1 l) arg)) (KindOf (Tuple3Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Tuple3Sym1 l) arg) ~ KindOf (Tuple3Sym2 l arg) =>
         Tuple3Sym1KindInference
     type instance Apply (Tuple3Sym1 l) l = Tuple3Sym2 l l
     instance SuppressUnusedWarnings Tuple3Sym0 where
@@ -71,13 +71,11 @@
     data Tuple3Sym0 (l :: TyFun a (TyFun b (TyFun c (GHC.Tuple.(,,) a b c)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Tuple3Sym0 arg)) (KindOf (Tuple3Sym1 arg)) =>
+      = forall arg. KindOf (Apply Tuple3Sym0 arg) ~ KindOf (Tuple3Sym1 arg) =>
         Tuple3Sym0KindInference
     type instance Apply Tuple3Sym0 l = Tuple3Sym1 l
     data instance Sing (z :: GHC.Tuple.(,,) a b c)
-      = forall (n :: a)
-               (n :: b)
-               (n :: c). (GHC.Types.~) z (GHC.Tuple.(,,) n n n) =>
+      = forall (n :: a) (n :: b) (n :: c). z ~ GHC.Tuple.(,,) n n n =>
         STuple3 (Sing n) (Sing n) (Sing n)
     type STuple3 (z :: GHC.Tuple.(,,) a b c) = Sing z
     instance (SingKind (KProxy :: KProxy a),
@@ -108,7 +106,7 @@
                     (l :: b)
                     (l :: c)
                     (l :: TyFun d (GHC.Tuple.(,,,) a b c d))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple4Sym3 l l l) arg)) (KindOf (Tuple4Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple4Sym3 l l l) arg) ~ KindOf (Tuple4Sym4 l l l arg) =>
         Tuple4Sym3KindInference
     type instance Apply (Tuple4Sym3 l l l) l = Tuple4Sym4 l l l l
     instance SuppressUnusedWarnings Tuple4Sym2 where
@@ -117,7 +115,7 @@
     data Tuple4Sym2 (l :: a)
                     (l :: b)
                     (l :: TyFun c (TyFun d (GHC.Tuple.(,,,) a b c d) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple4Sym2 l l) arg)) (KindOf (Tuple4Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple4Sym2 l l) arg) ~ KindOf (Tuple4Sym3 l l arg) =>
         Tuple4Sym2KindInference
     type instance Apply (Tuple4Sym2 l l) l = Tuple4Sym3 l l l
     instance SuppressUnusedWarnings Tuple4Sym1 where
@@ -126,7 +124,7 @@
     data Tuple4Sym1 (l :: a)
                     (l :: TyFun b (TyFun c (TyFun d (GHC.Tuple.(,,,) a b c d) -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple4Sym1 l) arg)) (KindOf (Tuple4Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Tuple4Sym1 l) arg) ~ KindOf (Tuple4Sym2 l arg) =>
         Tuple4Sym1KindInference
     type instance Apply (Tuple4Sym1 l) l = Tuple4Sym2 l l
     instance SuppressUnusedWarnings Tuple4Sym0 where
@@ -136,14 +134,14 @@
                                                      -> *)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Tuple4Sym0 arg)) (KindOf (Tuple4Sym1 arg)) =>
+      = forall arg. KindOf (Apply Tuple4Sym0 arg) ~ KindOf (Tuple4Sym1 arg) =>
         Tuple4Sym0KindInference
     type instance Apply Tuple4Sym0 l = Tuple4Sym1 l
     data instance Sing (z :: GHC.Tuple.(,,,) a b c d)
       = forall (n :: a)
                (n :: b)
                (n :: c)
-               (n :: d). (GHC.Types.~) z (GHC.Tuple.(,,,) n n n n) =>
+               (n :: d). z ~ GHC.Tuple.(,,,) n n n n =>
         STuple4 (Sing n) (Sing n) (Sing n) (Sing n)
     type STuple4 (z :: GHC.Tuple.(,,,) a b c d) = Sing z
     instance (SingKind (KProxy :: KProxy a),
@@ -178,7 +176,7 @@
                     (l :: c)
                     (l :: d)
                     (l :: TyFun e (GHC.Tuple.(,,,,) a b c d e))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple5Sym4 l l l l) arg)) (KindOf (Tuple5Sym5 l l l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple5Sym4 l l l l) arg) ~ KindOf (Tuple5Sym5 l l l l arg) =>
         Tuple5Sym4KindInference
     type instance Apply (Tuple5Sym4 l l l l) l = Tuple5Sym5 l l l l l
     instance SuppressUnusedWarnings Tuple5Sym3 where
@@ -188,7 +186,7 @@
                     (l :: b)
                     (l :: c)
                     (l :: TyFun d (TyFun e (GHC.Tuple.(,,,,) a b c d e) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple5Sym3 l l l) arg)) (KindOf (Tuple5Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple5Sym3 l l l) arg) ~ KindOf (Tuple5Sym4 l l l arg) =>
         Tuple5Sym3KindInference
     type instance Apply (Tuple5Sym3 l l l) l = Tuple5Sym4 l l l l
     instance SuppressUnusedWarnings Tuple5Sym2 where
@@ -198,7 +196,7 @@
                     (l :: b)
                     (l :: TyFun c (TyFun d (TyFun e (GHC.Tuple.(,,,,) a b c d e) -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple5Sym2 l l) arg)) (KindOf (Tuple5Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple5Sym2 l l) arg) ~ KindOf (Tuple5Sym3 l l arg) =>
         Tuple5Sym2KindInference
     type instance Apply (Tuple5Sym2 l l) l = Tuple5Sym3 l l l
     instance SuppressUnusedWarnings Tuple5Sym1 where
@@ -209,7 +207,7 @@
                                                      -> *)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple5Sym1 l) arg)) (KindOf (Tuple5Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Tuple5Sym1 l) arg) ~ KindOf (Tuple5Sym2 l arg) =>
         Tuple5Sym1KindInference
     type instance Apply (Tuple5Sym1 l) l = Tuple5Sym2 l l
     instance SuppressUnusedWarnings Tuple5Sym0 where
@@ -220,7 +218,7 @@
                                                      -> *)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Tuple5Sym0 arg)) (KindOf (Tuple5Sym1 arg)) =>
+      = forall arg. KindOf (Apply Tuple5Sym0 arg) ~ KindOf (Tuple5Sym1 arg) =>
         Tuple5Sym0KindInference
     type instance Apply Tuple5Sym0 l = Tuple5Sym1 l
     data instance Sing (z :: GHC.Tuple.(,,,,) a b c d e)
@@ -228,7 +226,7 @@
                (n :: b)
                (n :: c)
                (n :: d)
-               (n :: e). (GHC.Types.~) z (GHC.Tuple.(,,,,) n n n n n) =>
+               (n :: e). z ~ GHC.Tuple.(,,,,) n n n n n =>
         STuple5 (Sing n) (Sing n) (Sing n) (Sing n) (Sing n)
     type STuple5 (z :: GHC.Tuple.(,,,,) a b c d e) = Sing z
     instance (SingKind (KProxy :: KProxy a),
@@ -275,7 +273,7 @@
                     (l :: d)
                     (l :: e)
                     (l :: TyFun f (GHC.Tuple.(,,,,,) a b c d e f))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple6Sym5 l l l l l) arg)) (KindOf (Tuple6Sym6 l l l l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple6Sym5 l l l l l) arg) ~ KindOf (Tuple6Sym6 l l l l l arg) =>
         Tuple6Sym5KindInference
     type instance Apply (Tuple6Sym5 l l l l l) l = Tuple6Sym6 l l l l l l
     instance SuppressUnusedWarnings Tuple6Sym4 where
@@ -286,7 +284,7 @@
                     (l :: c)
                     (l :: d)
                     (l :: TyFun e (TyFun f (GHC.Tuple.(,,,,,) a b c d e f) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple6Sym4 l l l l) arg)) (KindOf (Tuple6Sym5 l l l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple6Sym4 l l l l) arg) ~ KindOf (Tuple6Sym5 l l l l arg) =>
         Tuple6Sym4KindInference
     type instance Apply (Tuple6Sym4 l l l l) l = Tuple6Sym5 l l l l l
     instance SuppressUnusedWarnings Tuple6Sym3 where
@@ -298,7 +296,7 @@
                     (l :: TyFun d (TyFun e (TyFun f (GHC.Tuple.(,,,,,) a b c d e f)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple6Sym3 l l l) arg)) (KindOf (Tuple6Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple6Sym3 l l l) arg) ~ KindOf (Tuple6Sym4 l l l arg) =>
         Tuple6Sym3KindInference
     type instance Apply (Tuple6Sym3 l l l) l = Tuple6Sym4 l l l l
     instance SuppressUnusedWarnings Tuple6Sym2 where
@@ -310,7 +308,7 @@
                                                      -> *)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple6Sym2 l l) arg)) (KindOf (Tuple6Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple6Sym2 l l) arg) ~ KindOf (Tuple6Sym3 l l arg) =>
         Tuple6Sym2KindInference
     type instance Apply (Tuple6Sym2 l l) l = Tuple6Sym3 l l l
     instance SuppressUnusedWarnings Tuple6Sym1 where
@@ -322,7 +320,7 @@
                                                      -> *)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple6Sym1 l) arg)) (KindOf (Tuple6Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Tuple6Sym1 l) arg) ~ KindOf (Tuple6Sym2 l arg) =>
         Tuple6Sym1KindInference
     type instance Apply (Tuple6Sym1 l) l = Tuple6Sym2 l l
     instance SuppressUnusedWarnings Tuple6Sym0 where
@@ -334,7 +332,7 @@
                                                      -> *)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Tuple6Sym0 arg)) (KindOf (Tuple6Sym1 arg)) =>
+      = forall arg. KindOf (Apply Tuple6Sym0 arg) ~ KindOf (Tuple6Sym1 arg) =>
         Tuple6Sym0KindInference
     type instance Apply Tuple6Sym0 l = Tuple6Sym1 l
     data instance Sing (z :: GHC.Tuple.(,,,,,) a b c d e f)
@@ -343,7 +341,7 @@
                (n :: c)
                (n :: d)
                (n :: e)
-               (n :: f). (GHC.Types.~) z (GHC.Tuple.(,,,,,) n n n n n n) =>
+               (n :: f). z ~ GHC.Tuple.(,,,,,) n n n n n n =>
         STuple6 (Sing n) (Sing n) (Sing n) (Sing n) (Sing n) (Sing n)
     type STuple6 (z :: GHC.Tuple.(,,,,,) a b c d e f) = Sing z
     instance (SingKind (KProxy :: KProxy a),
@@ -400,7 +398,7 @@
                     (l :: e)
                     (l :: f)
                     (l :: TyFun g (GHC.Tuple.(,,,,,,) a b c d e f g))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple7Sym6 l l l l l l) arg)) (KindOf (Tuple7Sym7 l l l l l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple7Sym6 l l l l l l) arg) ~ KindOf (Tuple7Sym7 l l l l l l arg) =>
         Tuple7Sym6KindInference
     type instance Apply (Tuple7Sym6 l l l l l l) l = Tuple7Sym7 l l l l l l l
     instance SuppressUnusedWarnings Tuple7Sym5 where
@@ -412,7 +410,7 @@
                     (l :: d)
                     (l :: e)
                     (l :: TyFun f (TyFun g (GHC.Tuple.(,,,,,,) a b c d e f g) -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple7Sym5 l l l l l) arg)) (KindOf (Tuple7Sym6 l l l l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple7Sym5 l l l l l) arg) ~ KindOf (Tuple7Sym6 l l l l l arg) =>
         Tuple7Sym5KindInference
     type instance Apply (Tuple7Sym5 l l l l l) l = Tuple7Sym6 l l l l l l
     instance SuppressUnusedWarnings Tuple7Sym4 where
@@ -425,7 +423,7 @@
                     (l :: TyFun e (TyFun f (TyFun g (GHC.Tuple.(,,,,,,) a b c d e f g)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple7Sym4 l l l l) arg)) (KindOf (Tuple7Sym5 l l l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple7Sym4 l l l l) arg) ~ KindOf (Tuple7Sym5 l l l l arg) =>
         Tuple7Sym4KindInference
     type instance Apply (Tuple7Sym4 l l l l) l = Tuple7Sym5 l l l l l
     instance SuppressUnusedWarnings Tuple7Sym3 where
@@ -438,7 +436,7 @@
                                                      -> *)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple7Sym3 l l l) arg)) (KindOf (Tuple7Sym4 l l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple7Sym3 l l l) arg) ~ KindOf (Tuple7Sym4 l l l arg) =>
         Tuple7Sym3KindInference
     type instance Apply (Tuple7Sym3 l l l) l = Tuple7Sym4 l l l l
     instance SuppressUnusedWarnings Tuple7Sym2 where
@@ -451,7 +449,7 @@
                                                      -> *)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple7Sym2 l l) arg)) (KindOf (Tuple7Sym3 l l arg)) =>
+      = forall arg. KindOf (Apply (Tuple7Sym2 l l) arg) ~ KindOf (Tuple7Sym3 l l arg) =>
         Tuple7Sym2KindInference
     type instance Apply (Tuple7Sym2 l l) l = Tuple7Sym3 l l l
     instance SuppressUnusedWarnings Tuple7Sym1 where
@@ -464,7 +462,7 @@
                                                      -> *)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply (Tuple7Sym1 l) arg)) (KindOf (Tuple7Sym2 l arg)) =>
+      = forall arg. KindOf (Apply (Tuple7Sym1 l) arg) ~ KindOf (Tuple7Sym2 l arg) =>
         Tuple7Sym1KindInference
     type instance Apply (Tuple7Sym1 l) l = Tuple7Sym2 l l
     instance SuppressUnusedWarnings Tuple7Sym0 where
@@ -477,7 +475,7 @@
                                                      -> *)
                                             -> *)
                                    -> *))
-      = forall arg. (GHC.Types.~) (KindOf (Apply Tuple7Sym0 arg)) (KindOf (Tuple7Sym1 arg)) =>
+      = forall arg. KindOf (Apply Tuple7Sym0 arg) ~ KindOf (Tuple7Sym1 arg) =>
         Tuple7Sym0KindInference
     type instance Apply Tuple7Sym0 l = Tuple7Sym1 l
     data instance Sing (z :: GHC.Tuple.(,,,,,,) a b c d e f g)
@@ -487,7 +485,7 @@
                (n :: d)
                (n :: e)
                (n :: f)
-               (n :: g). (GHC.Types.~) z (GHC.Tuple.(,,,,,,) n n n n n n n) =>
+               (n :: g). z ~ GHC.Tuple.(,,,,,,) n n n n n n n =>
         STuple7 (Sing n) (Sing n) (Sing n) (Sing n) (Sing n) (Sing n) (Sing n)
     type STuple7 (z :: GHC.Tuple.(,,,,,,) a b c d e f g) = Sing z
     instance (SingKind (KProxy :: KProxy a),