diff --git a/CHANGES.md b/CHANGES.md
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,143 @@
 Changelog for the `singletons-base` project
 ===========================================
 
+3.5.1 [2026.01.10]
+------------------
+* Require building with GHC 9.14.
+
+3.5 [2024.12.11]
+----------------
+* Require building with GHC 9.12.
+* Remove the use of a custom `Setup.hs` script. This script has now been
+  replaced with a [`cabal` code
+  generator](https://cabal.readthedocs.io/en/stable/cabal-package-description-file.html#pkg-field-test-suite-code-generators)
+  As such, `singletons-base` now requires the use of `Cabal-3.8` or later in
+  order to build.
+* The types of `sError`, `sErrorWithoutStackTrace`, and `sUndefined` are now
+  less polymorphic than they were before:
+
+  ```diff
+  -sError :: forall a (str :: Symbol). HasCallStack => Sing str -> a
+  +sError :: forall a (str :: Symbol). HasCallStack => Sing str -> Sing (Error @a str)
+
+  -sErrorWithoutStackTrace :: forall a (str :: Symbol). Sing str -> a
+  +sErrorWithoutStackTrace :: forall a (str :: Symbol). Sing str -> Sing (ErrorWithoutStackTrace @a str)
+
+  -sUndefined :: forall a. HasCallStack => a
+  +sUndefined :: forall a. HasCallStack => Sing (Undefined @a)
+  ```
+
+  This is because the old type signatures were _too_ polymorphic, and they
+  required _ad hoc_ special casing in `singletons-th` in order to make them
+  work in generated code. The more specific type signatures that these functions
+  now have improve type inference and avoid the need for special casing. If you
+  truly need the full polymorphism of the old type signatures, use `error`,
+  `errorWithoutStackTrace`, or `undefined` instead.
+* The kinds of `PAlternative` (and other classes in `singletons-base` that are
+  parameterized over a higher-kinded type variable) are less polymorphic than
+  they were before:
+
+  ```diff
+  -type PAlternative :: (k    -> Type) -> Constraint
+  +type PAlternative :: (Type -> Type) -> Constraint
+
+  -type PMonadZip :: (k    -> Type) -> Constraint
+  +type PMonadZip :: (Type -> Type) -> Constraint
+
+  -type PMonadPlus :: (k    -> Type) -> Constraint
+  +type PMonadPlus :: (Type -> Type) -> Constraint
+  ```
+
+  Similarly, the kinds of defunctionalization symbols for these classes (e.g.,
+  `EmptySym0` and `(<|>@#@$)`) now use `Type -> Type` instead of `k -> Type`.
+  The fact that these were kind-polymorphic to begin with was an oversight, as
+  these could not be used when `k` was instantiated to any other kind besides
+  `Type`.
+* The kinds in the `PFunctor` instance for `Compose` are less polymorphic than
+  they were before:
+
+  ```diff
+  -instance PFunctor (Compose (f :: k    -> Type) (g :: Type -> k))
+  +instance PFunctor (Compose (f :: Type -> Type) (g :: Type -> Type))
+  ```
+
+  Similarly for the `PFoldable`, `PTraversable`, `PApplicative`, and
+  `PAlternative` instances for `Compose`. The fact that these instances were so
+  polymorphic to begin with was an oversight, as these instances could not be
+  used when `k` was instantiated to any other kind besides `Type`.
+* The kinds of `Asum` and `Msum` are less polymorphic than they were before:
+
+  ```diff
+  -type Asum :: forall {j} {k} (t :: k    -> Type) (f :: j    -> k)    (a :: j).    t (f a) -> f a
+  +type Asum :: forall         (t :: Type -> Type) (f :: Type -> Type) (a :: Type). t (f a) -> f a
+
+  -type Msum :: forall {j} {k} (t :: k    -> Type) (m :: j    -> k)    (a :: j).    t (m a) -> m a
+  +type Msum :: forall         (t :: Type -> Type) (m :: Type -> Type) (a :: Type). t (m a) -> m a
+  ```
+
+  Similarly, the kinds of defunctionalization symbols for these definitions
+  (e.g., `AsumSym0` and `MSym0`) are less polymorphic. The fact that these were
+  kind-polymorphic to begin with was an oversight, as these definitions could
+  not be used when `j` or `k` was instantiated to any other kind besides `Type`.
+* Define hand-written `Sing` instances such that they explicitly match on their
+  types on the left-hand sides (e.g., define `type instance Sing @Symbol =
+  SSymbol` instead of `type instance Sing = SSymbol`. Doing so will make
+  `singletons-base` future-proof once
+  [GHC#23515](https://gitlab.haskell.org/ghc/ghc/-/issues/23515) is fixed.
+
+3.4 [2024.05.12]
+----------------
+* Require building with GHC 9.10.
+
+3.3 [2023.10.13]
+----------------
+* Require building with GHC 9.8.
+* All singleton types with `SEq` or `SOrd` instances now have `Eq` or `Ord`
+  instances of the form:
+
+  ```hs
+  instance Eq (SExample a) where
+    _ == _ = True
+
+  instance Ord (SExample a) where
+    compare _ _ = EQ
+  ```
+* Define `{P,S}Eq` and `{P,S}Ord` instances for `Sum`, `Product`, and `Compose`.
+* Define `TestEquality` and `TestOrdering` instances for `SSum`, `SProduct`, and
+  `SCompose`.
+
+3.2 [2023.03.12]
+----------------
+* Require building with GHC 9.6.
+* The kinds of the promoted `Error` and `ErrorWithoutStackTrace` functions have
+  been monomorphized to `Symbol`. A previous release generalized the kinds of
+  these arguments to allow passing arguments besides `Symbol`s, but this change
+  introduces ambiguity in derived code when `OverloadedString`s is enabled.
+  See [#89](https://github.com/goldfirere/singletons/issues/89) for the full
+  story.
+
+  If you were relying on the previous, kind-polymorphic behavior of `Error`, you
+  can instead use the new `Data.Singletons.Base.PolyError` module that provides
+  `PolyError`, a version of `Error` with a kind-polymorphic argument.
+* `Data.Ord.Singletons` and `Data.Singletons.Base.TH` no longer define a
+  `thenCmp :: Ordering -> Ordering -> Ordering` function, as this is not
+  something that has ever existed in `base`. The existence of a `thenCmp`
+  function was solely motivated by the code generated by derived `Ord`
+  instances, but `singletons-base` now uses `(<>) @Ordering` instead.
+* `GHC.TypeLits.Singletons` now re-exports the `SChar`, `SNat`, and `SSymbol`
+  singleton types offered by `GHC.TypeLits` in `base-4.18.0.0` rather than
+  defining its own versions. The versions of `SChar`, `SNat`, and `SSymbol`
+  offered by `GHC.TypeLits` are nearly identical, minus some minor cosmetic
+  changes (e.g., `GHC.TypeLits` defines pattern synonyms for `SNat` _et a._
+  instead of data constructors).
+* `GHC.TypeLits.Singletons` now re-exports the `SSymbol` pattern synonym
+  from `GHC.TypeLits`. `GHC.TypeLits.Singletons` also continues to export `SSym`
+  for backwards compatibility.
+* `Prelude.Singletons` now re-exports `LiftA2` and `sLiftA2`, mirroring the
+  fact that `Prelude` now re-exports `liftA2` in `base-4.18.0.0`.
+* Provide `TestEquality` and `TestCoercion` instances for `SNat, `SSymbol`, and
+  `SChar`.
+
 3.1.1 [2022.08.23]
 ------------------
 * Require building with GHC 9.4.
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@
 
 `singletons-base` uses code that relies on bleeding-edge GHC language
 extensions. As such, `singletons-base` only supports the latest major version
-of GHC (currently GHC 9.4). For more information,
+of GHC (currently GHC 9.14). For more information,
 consult the `singletons`
 [`README`](https://github.com/goldfirere/singletons/blob/master/README.md).
 
diff --git a/Setup.hs b/Setup.hs
--- a/Setup.hs
+++ b/Setup.hs
@@ -1,138 +1,7 @@
 {-# OPTIONS_GHC -Wall #-}
-module Main (main) where
-
-import Control.Monad
-
-import qualified Data.List as List
-import Data.String
+module Main where
 
-import Distribution.PackageDescription
 import Distribution.Simple
-import Distribution.Simple.BuildPaths
-import Distribution.Simple.LocalBuildInfo
-import Distribution.Simple.PackageIndex
-import Distribution.Simple.Program
-import Distribution.Simple.Setup
-import Distribution.Simple.Utils
-import Distribution.Text
 
-import System.Directory
-import System.FilePath
-
 main :: IO ()
-main = defaultMainWithHooks simpleUserHooks
-  { buildHook = \pkg lbi hooks flags -> do
-      generateBuildModule flags pkg lbi
-      buildHook simpleUserHooks pkg lbi hooks flags
-  , confHook = \(gpd, hbi) flags ->
-      confHook simpleUserHooks (amendGPD gpd, hbi) flags
-  , haddockHook = \pkg lbi hooks flags -> do
-      generateBuildModule (haddockToBuildFlags flags) pkg lbi
-      haddockHook simpleUserHooks pkg lbi hooks flags
-  }
-
--- | Convert only flags used by 'generateBuildModule'.
-haddockToBuildFlags :: HaddockFlags -> BuildFlags
-haddockToBuildFlags f = emptyBuildFlags
-    { buildVerbosity = haddockVerbosity f
-    , buildDistPref  = haddockDistPref f
-    }
-
-generateBuildModule :: BuildFlags -> PackageDescription -> LocalBuildInfo -> IO ()
-generateBuildModule flags pkg lbi = do
-  rootDir <- getCurrentDirectory
-  let verbosity = fromFlag (buildVerbosity flags)
-      distPref  = fromFlag (buildDistPref flags)
-      distPref' | isRelative distPref = rootDir </> distPref
-                | otherwise           = distPref
-      -- Package DBs
-      dbStack = withPackageDB lbi ++ [ SpecificPackageDB $ distPref' </> "package.conf.inplace" ]
-      dbFlags = "-hide-all-packages" : "-package-env=-" : packageDbArgsDb dbStack
-
-      ghc = case lookupProgram ghcProgram (withPrograms lbi) of
-              Just fp -> locationPath $ programLocation fp
-              Nothing -> error "Can't find GHC path"
-  withTestLBI pkg lbi $ \suite suitecfg -> when (testName suite == fromString testSuiteName) $ do
-    let testAutogenDir = autogenComponentModulesDir lbi suitecfg
-    createDirectoryIfMissingVerbose verbosity True testAutogenDir
-    let buildSingletonsBaseFile = testAutogenDir </> buildSingletonsBaseModule <.> "hs"
-    withLibLBI pkg lbi $ \_ libCLBI -> do
-      let libDeps = map fst $ componentPackageDeps libCLBI
-          pidx = case dependencyClosure (installedPkgs lbi) libDeps of
-                   Left p  -> p
-                   Right _ -> error "Broken dependency closure"
-          libTransDeps = map installedUnitId $ allPackages pidx
-          singletonsBaseUnitId = componentUnitId libCLBI
-          deps = formatDeps (singletonsBaseUnitId:libTransDeps)
-          allFlags = dbFlags ++ deps
-      writeFile buildSingletonsBaseFile $ unlines
-        [ "module Build_singletons_base where"
-        , ""
-        , "ghcPath :: FilePath"
-        , "ghcPath = " ++ show ghc
-        , ""
-        , "ghcFlags :: [String]"
-        , "ghcFlags = " ++ show allFlags
-        , ""
-        , "rootDir :: FilePath"
-        , "rootDir = " ++ show rootDir
-        ]
-  where
-    formatDeps = map formatOne
-    formatOne installedPkgId = "-package-id=" ++ display installedPkgId
-
-    -- GHC >= 7.6 uses the '-package-db' flag. See
-    -- https://ghc.haskell.org/trac/ghc/ticket/5977.
-    packageDbArgsDb :: [PackageDB] -> [String]
-    -- special cases to make arguments prettier in common scenarios
-    packageDbArgsDb dbstack = case dbstack of
-      (GlobalPackageDB:UserPackageDB:dbs)
-        | all isSpecific dbs              -> concatMap single dbs
-      (GlobalPackageDB:dbs)
-        | all isSpecific dbs              -> "-no-user-package-db"
-                                           : concatMap single dbs
-      dbs                                 -> "-clear-package-db"
-                                           : concatMap single dbs
-     where
-       single (SpecificPackageDB db) = [ "-package-db=" ++ db ]
-       single GlobalPackageDB        = [ "-global-package-db" ]
-       single UserPackageDB          = [ "-user-package-db" ]
-       isSpecific (SpecificPackageDB _) = True
-       isSpecific _                     = False
-
-buildSingletonsBaseModule :: FilePath
-buildSingletonsBaseModule = "Build_singletons_base"
-
-testSuiteName :: String
-testSuiteName = "singletons-base-test-suite"
-
-amendGPD :: GenericPackageDescription -> GenericPackageDescription
-amendGPD gpd = gpd
-    { condTestSuites = map f (condTestSuites gpd)
-    }
-  where
-    f (name, condTree)
-        | name == fromString testSuiteName = (name, condTree')
-        | otherwise                        = (name, condTree)
-      where
-        -- I miss 'lens'
-        testSuite = condTreeData condTree
-        bi = testBuildInfo testSuite
-        om = otherModules bi
-        am = autogenModules bi
-
-        -- Cons the module to both other-modules and autogen-modules.
-        -- At the moment, cabal-spec-2.0 and cabal-spec-2.2 don't have
-        -- "all autogen-modules are other-modules if they aren't exposed-modules"
-        -- rule. Hopefully cabal-spec-3.0 will have.
-        --
-        -- Note: we `nub`, because it's unclear if that's ok to have duplicate
-        -- modules in the lists.
-        om' = List.nub $ mn : om
-        am' = List.nub $ mn : am
-
-        mn = fromString buildSingletonsBaseModule
-
-        bi' = bi { otherModules = om', autogenModules = am' }
-        testSuite' = testSuite { testBuildInfo = bi' }
-        condTree' = condTree { condTreeData = testSuite' }
+main = defaultMain
diff --git a/singletons-base.cabal b/singletons-base.cabal
--- a/singletons-base.cabal
+++ b/singletons-base.cabal
@@ -1,6 +1,6 @@
+cabal-version:  3.8
 name:           singletons-base
-version:        3.1.1
-cabal-version:  1.24
+version:        3.5.1
 synopsis:       A promoted and singled version of the base library
 homepage:       http://www.github.com/goldfirere/singletons
 category:       Dependent Types
@@ -8,19 +8,21 @@
 maintainer:     Ryan Scott <ryan.gl.scott@gmail.com>
 bug-reports:    https://github.com/goldfirere/singletons/issues
 stability:      experimental
-tested-with:    GHC == 9.4.1
-extra-source-files: README.md, CHANGES.md, tests/README.md,
-                    tests/compile-and-dump/GradingClient/*.hs,
-                    tests/compile-and-dump/InsertionSort/*.hs,
-                    tests/compile-and-dump/Promote/*.hs,
+tested-with:    GHC == 9.14.1
+extra-doc-files:    CHANGES.md
+extra-source-files: README.md
+                    tests/README.md
+                    tests/compile-and-dump/GradingClient/*.hs
+                    tests/compile-and-dump/InsertionSort/*.hs
+                    tests/compile-and-dump/Promote/*.hs
                     tests/compile-and-dump/Singletons/*.hs
-                    tests/compile-and-dump/GradingClient/*.golden,
-                    tests/compile-and-dump/InsertionSort/*.golden,
-                    tests/compile-and-dump/Promote/*.golden,
+                    tests/compile-and-dump/GradingClient/*.golden
+                    tests/compile-and-dump/InsertionSort/*.golden
+                    tests/compile-and-dump/Promote/*.golden
                     tests/compile-and-dump/Singletons/*.golden
-license:        BSD3
+license:        BSD-3-Clause
 license-file:   LICENSE
-build-type:     Custom
+build-type:     Simple
 description:
     @singletons-base@ uses @singletons-th@ to define promoted and singled
     functions from the @base@ library, including the "Prelude". This library was
@@ -38,7 +40,7 @@
     .
     @singletons-base@ uses code that relies on bleeding-edge GHC language
     extensions. As such, @singletons-base@ only supports the latest major version
-    of GHC (currently GHC 9.4). For more information,
+    of GHC (currently GHC 9.14). For more information,
     consult the @singletons@
     @<https://github.com/goldfirere/singletons/blob/master/README.md README>@.
     .
@@ -55,7 +57,7 @@
   type:     git
   location: https://github.com/goldfirere/singletons.git
   subdir:   singletons-base
-  tag:      v3.1.1
+  tag:      v3.1.2
 
 source-repository head
   type:     git
@@ -63,27 +65,20 @@
   subdir:   singletons-base
   branch:   master
 
-custom-setup
-  setup-depends:
-    base      >= 4.17 && < 4.18,
-    Cabal     >= 3.0 && < 3.9,
-    directory >= 1,
-    filepath  >= 1.3
-
 library
   hs-source-dirs:     src
-  build-depends:      base             >= 4.17 && < 4.18,
+  build-depends:      base             >= 4.22 && < 4.23,
                       pretty,
                       singletons       == 3.0.*,
-                      singletons-th    == 3.1.*,
-                      template-haskell >= 2.19 && < 2.20,
-                      text >= 1.2,
-                      th-desugar       >= 1.14 && < 1.15
-  default-language:   GHC2021
+                      singletons-th    >= 3.5.1 && < 3.6,
+                      template-haskell >= 2.24 && < 2.25,
+                      text >= 1.2
+  default-language:   GHC2024
   other-extensions:   TemplateHaskell
   exposed-modules:    Data.Singletons.Base.CustomStar
                       Data.Singletons.Base.Enum
                       Data.Singletons.Base.TH
+                      Data.Singletons.Base.PolyError
                       Data.Singletons.Base.SomeSing
                       Data.Singletons.Base.TypeError
                       Data.Singletons.Base.TypeRepTYPE
@@ -125,8 +120,9 @@
                       Data.List.Singletons.Internal
                       Data.List.Singletons.Internal.Disambiguation
                       Data.Ord.Singletons.Disambiguation
-                      Data.Semigroup.Singletons.Internal
+                      Data.Semigroup.Singletons.Internal.Classes
                       Data.Semigroup.Singletons.Internal.Disambiguation
+                      Data.Semigroup.Singletons.Internal.Wrappers
                       GHC.Base.Singletons
                       GHC.Num.Singletons
                       GHC.TypeLits.Singletons.Internal
@@ -149,17 +145,29 @@
   type:               exitcode-stdio-1.0
   hs-source-dirs:     tests
   ghc-options:        -Wall -Wcompat -threaded -with-rtsopts=-maxN16
-  default-language:   GHC2021
+  default-language:   GHC2024
   main-is:            SingletonsBaseTestSuite.hs
   other-modules:      SingletonsBaseTestSuiteUtils
 
-  build-depends:      base >= 4.17 && < 4.18,
+  build-depends:      base >= 4.22 && < 4.23,
                       bytestring >= 0.10.9,
                       deepseq >= 1.4.4,
                       filepath >= 1.3,
+                      ghc-paths >= 0.1,
                       process >= 1.1,
                       turtle >= 1.5,
                       text >= 1.2,
                       singletons-base,
                       tasty >= 1.2,
-                      tasty-golden >= 2.2
+                      tasty-golden >= 2.2,
+
+                      -- Dependencies only used when invoking GHC in the test
+                      -- suite
+                      ghc-prim,
+                      ghc-internal,
+                      mtl,
+                      template-haskell,
+                      th-desugar,
+                      transformers
+  build-tool-depends: singletons-base-code-generator:singletons-base-code-generator
+  code-generators:    singletons-base-code-generator
diff --git a/src/Control/Applicative/Singletons.hs b/src/Control/Applicative/Singletons.hs
--- a/src/Control/Applicative/Singletons.hs
+++ b/src/Control/Applicative/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
diff --git a/src/Control/Monad/Fail/Singletons.hs b/src/Control/Monad/Fail/Singletons.hs
--- a/src/Control/Monad/Fail/Singletons.hs
+++ b/src/Control/Monad/Fail/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
@@ -24,6 +24,7 @@
   ) where
 
 import Control.Monad.Singletons.Internal
+import Data.Kind
 import Data.Singletons.Base.Instances
 import Data.Singletons.TH
 
@@ -48,6 +49,10 @@
   -- @
   -- fail _ = mzero
   -- @
+
+  -- See Note [Using standalone kind signatures not present in the base library]
+  -- in Control.Monad.Singletons.Internal.
+  type MonadFail :: (Type -> Type) -> Constraint
   class Monad m => MonadFail m where
       fail :: String -> m a
 
diff --git a/src/Control/Monad/Singletons.hs b/src/Control/Monad/Singletons.hs
--- a/src/Control/Monad/Singletons.hs
+++ b/src/Control/Monad/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
@@ -83,7 +83,6 @@
   type (<$!>@#@$), type (<$!>@#@$$), type (<$!>@#@$$$),
   ) where
 
-import Control.Applicative
 import Control.Applicative.Singletons ()
 import Control.Monad
 import Control.Monad.Fail.Singletons
diff --git a/src/Control/Monad/Singletons/Internal.hs b/src/Control/Monad/Singletons/Internal.hs
--- a/src/Control/Monad/Singletons/Internal.hs
+++ b/src/Control/Monad/Singletons/Internal.hs
@@ -1,7 +1,7 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE NoNamedWildCards #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
@@ -32,6 +32,7 @@
 
 import Control.Applicative
 import Control.Monad
+import Data.Kind
 import Data.List.NonEmpty (NonEmpty(..))
 import Data.Singletons.Base.Instances
 import Data.Singletons.TH
@@ -50,6 +51,8 @@
   satisfy these laws.
   -}
 
+  -- See Note [Using standalone kind signatures not present in the base library]
+  type   Functor :: (Type -> Type) -> Constraint
   class  Functor f  where
       fmap        :: (a -> b) -> f a -> f b
 
@@ -125,6 +128,8 @@
   --
   -- (which implies that 'pure' and '<*>' satisfy the applicative functor laws).
 
+  -- See Note [Using standalone kind signatures not present in the base library]
+  type Applicative :: (Type -> Type) -> Constraint
   class Functor f => Applicative f where
       -- {-# MINIMAL pure, ((<*>) | liftA2) #-}
       -- -| Lift a value.
@@ -242,6 +247,9 @@
   The instances of 'Monad' for lists, 'Data.Maybe.Maybe' and 'System.IO.IO'
   defined in the "Prelude" satisfy these laws.
   -}
+
+  -- See Note [Using standalone kind signatures not present in the base library]
+  type Monad :: (Type -> Type) -> Constraint
   class Applicative m => Monad m where
       -- -| Sequentially compose two actions, passing any value produced
       -- by the first as an argument to the second.
@@ -351,6 +359,9 @@
   -- -* @'some' v = (:) '<$>' v '<*>' 'many' v@
   --
   -- -* @'many' v = 'some' v '<|>' 'pure' []@
+
+  -- See Note [Using standalone kind signatures not present in the base library]
+  type Alternative :: (Type -> Type) -> Constraint
   class Applicative f => Alternative f where
       -- -| The identity of '<|>'
       empty :: f a
@@ -385,6 +396,9 @@
   -- The MonadPlus class definition
 
   -- -| Monads that also support choice and failure.
+
+  -- See Note [Using standalone kind signatures not present in the base library]
+  type MonadPlus :: (Type -> Type) -> Constraint
   class (Alternative m, Monad m) => MonadPlus m where
      -- -| The identity of 'mplus'.  It should also satisfy the equations
      --
@@ -478,3 +492,18 @@
   instance MonadPlus Maybe
   instance MonadPlus []
   |])
+
+{-
+Note [Using standalone kind signatures not present in the base library]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Various type class definitions in singletons-base (Functor, Foldable,
+Alternative, etc.) are defined using standalone kind signatures. These
+standalone kind signatures are /not/ present in the original `base` library,
+however: these are specifically required by singletons-th. More precisely, all
+of these classes are parameterized by a type variable of kind `Type -> Type`,
+and we want to ensure that the promoted class (and the defunctionalization
+symbols for its class methods) all use `Type -> Type` in their kinds as well.
+For more details on why singletons-th requires this, see Note [Propagating kind
+information from class standalone kind signatures] in D.S.TH.Promote in
+singletons-th.
+-}
diff --git a/src/Control/Monad/Zip/Singletons.hs b/src/Control/Monad/Zip/Singletons.hs
--- a/src/Control/Monad/Zip/Singletons.hs
+++ b/src/Control/Monad/Zip/Singletons.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
@@ -29,6 +29,7 @@
 import Control.Monad.Singletons.Internal
 import Data.Functor.Identity
 import Data.Functor.Identity.Singletons
+import Data.Kind
 import Data.List.Singletons
        ( ZipSym0, ZipWithSym0, UnzipSym0
        , sZip,    sZipWith,    sUnzip )
@@ -55,6 +56,10 @@
   --   > ==>
   --   > munzip (mzip ma mb) = (ma, mb)
   --
+
+  -- See Note [Using standalone kind signatures not present in the base library]
+  -- in Control.Monad.Singletons.Internal.
+  type MonadZip :: (Type -> Type) -> Constraint
   class Monad m => MonadZip m where
       -- {-# MINIMAL mzip | mzipWith #-}
 
diff --git a/src/Data/Bool/Singletons.hs b/src/Data/Bool/Singletons.hs
--- a/src/Data/Bool/Singletons.hs
+++ b/src/Data/Bool/Singletons.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE NoNamedWildCards #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/src/Data/Either/Singletons.hs b/src/Data/Either/Singletons.hs
--- a/src/Data/Either/Singletons.hs
+++ b/src/Data/Either/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/src/Data/Eq/Singletons.hs b/src/Data/Eq/Singletons.hs
--- a/src/Data/Eq/Singletons.hs
+++ b/src/Data/Eq/Singletons.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/src/Data/Foldable/Singletons.hs b/src/Data/Foldable/Singletons.hs
--- a/src/Data/Foldable/Singletons.hs
+++ b/src/Data/Foldable/Singletons.hs
@@ -1,7 +1,7 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE NoNamedWildCards #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
@@ -110,14 +110,7 @@
 import Data.Ord.Singletons
   hiding ( Max, MaxSym0, MaxSym1, MaxSym2, sMax
          , Min, MinSym0, MinSym1, MinSym2, sMin )
-import Data.Semigroup.Singletons.Internal
-  hiding ( AllSym0(..),     AllSym1,     SAll
-         , AnySym0(..),     AnySym1,     SAny
-         , FirstSym0,       FirstSym1,   SFirst
-         , GetFirstSym0,    sGetFirst
-         , LastSym0,        LastSym1,    SLast
-         , ProductSym0(..), ProductSym1, SProduct
-         , SumSym0(..),     SumSym1,     SSum )
+import Data.Semigroup.Singletons.Internal.Classes
 import Data.Semigroup.Singletons.Internal.Disambiguation
 import Data.Singletons
 import Data.Singletons.Base.Instances
@@ -133,7 +126,7 @@
 type SEndo :: Endo a -> Type
 data SEndo e where
   SEndo :: Sing x -> SEndo ('Endo x)
-type instance Sing = SEndo
+type instance Sing @(Endo a) = SEndo
 type EndoSym0 :: (a ~> a) ~> Endo a
 data EndoSym0 tf
 type instance Apply EndoSym0 x = 'Endo x
@@ -221,6 +214,9 @@
   --
   -- > foldMap f . fmap g = foldMap (f . g)
 
+  -- See Note [Using standalone kind signatures not present in the base library]
+  -- in Control.Monad.Singletons.Internal.
+  type Foldable :: (Type -> Type) -> Constraint
   class Foldable t where
       -- {-# MINIMAL foldMap | foldr #-}
 
@@ -584,16 +580,37 @@
   sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
   sequence_ = foldr (>>) (return ())
 
+  -- Note that in the type signatures for `asum` and `msum` below, we explicitly
+  -- annotate `f` and `m` with the kind (Type -> Type), which is not something
+  -- that is done in the original base library. This is because when
+  -- singletons-th promotes type signatures, it omits constraints such as
+  -- `Alternative f` and `MonadPlus m`, which are essential for inferring that
+  -- `f` and `m` are of kind `Type -> Type`. Without these constraints, we may
+  -- end up with a promoted definition that looks like this:
+  --
+  --   type Asum :: t (f a) -> f a
+  --
+  -- This will result in Asum having a more polymorphic kind than intended,
+  -- since GHC will generalize Asum's kind to:
+  --
+  --   type Asum :: forall {j} {k} (t :: k -> Type) (f :: j -> k) (a :: j). t (f a) -> f a
+  --
+  -- Annotating `f :: Type -> Type` (and similarly for `m`) is a clunky but
+  -- reliable way of preventing this. See also Note [Using standalone kind
+  -- signatures not present in the base library] in
+  -- Control.Monad.Singletons.Internal for a similar situation where class
+  -- definitions can become overly polymorphic unless given an explicit kind.
+
   -- -| The sum of a collection of actions, generalizing 'concat'.
   --
   -- asum [Just "Hello", Nothing, Just "World"]
   -- Just "Hello"
-  asum :: (Foldable t, Alternative f) => t (f a) -> f a
+  asum :: forall t (f :: Type -> Type) a. (Foldable t, Alternative f) => t (f a) -> f a
   asum = foldr (<|>) empty
 
   -- -| The sum of a collection of actions, generalizing 'concat'.
   -- As of base 4.8.0.0, 'msum' is just 'asum', specialized to 'MonadPlus'.
-  msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
+  msum :: forall t (m :: Type -> Type) a. (Foldable t, MonadPlus m) => t (m a) -> m a
   msum = asum
 
   -- -| The concatenation of all the elements of a container of lists.
diff --git a/src/Data/Function/Singletons.hs b/src/Data/Function/Singletons.hs
--- a/src/Data/Function/Singletons.hs
+++ b/src/Data/Function/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/src/Data/Functor/Compose/Singletons.hs b/src/Data/Functor/Compose/Singletons.hs
--- a/src/Data/Functor/Compose/Singletons.hs
+++ b/src/Data/Functor/Compose/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
@@ -28,65 +28,57 @@
 
 import Control.Applicative
 import Control.Applicative.Singletons
+import Data.Eq.Singletons
 import Data.Foldable.Singletons
 import Data.Functor.Compose
 import Data.Functor.Singletons
+import Data.Ord.Singletons
 import Data.Kind
-import Data.Singletons
+import Data.Semigroup.Singletons
+import Data.Singletons.Base.Instances (SList(..), (:@#@$), NilSym0)
 import Data.Singletons.TH
+import Data.Singletons.TH.Options
 import Data.Traversable.Singletons
 
-{-
-In order to keep the type arguments to Compose poly-kinded and with inferred
-specificities, we define the singleton version of Compose, as well as its
-defunctionalization symbols, by hand. This is very much in the spirit of the
-code in Data.Functor.Const.Singletons. (See the comments above SConst in that
-module for more details on this choice.)
--}
-infixr 9 `SCompose`
-type SCompose :: Compose f g a -> Type
-data SCompose :: Compose f g a -> Type where
-  SCompose :: forall f g a (x :: f (g a)).
-              Sing x -> SCompose ('Compose @f @g @a x)
-type instance Sing = SCompose
-instance SingI x => SingI ('Compose x) where
-  sing = SCompose sing
-instance SingI1 'Compose where
-  liftSing = SCompose
-
-infixr 9 `ComposeSym0`
-type ComposeSym0 :: f (g a) ~> Compose f g a
-data ComposeSym0 z
-type instance Apply ComposeSym0 x = 'Compose x
-instance SingI ComposeSym0 where
-  sing = singFun1 SCompose
-
-infixr 9 `ComposeSym1`
-type ComposeSym1 :: f (g a) -> Compose f g a
-type family ComposeSym1 x where
-  ComposeSym1 x = 'Compose x
+$(withOptions defaultOptions{genSingKindInsts = False}
+    (genSingletons [''Compose]))
 
 $(singletonsOnly [d|
-  getCompose :: Compose f g a -> f (g a)
-  getCompose (Compose x) = x
+  deriving instance Eq (f (g a)) => Eq (Compose f g a)
+  deriving instance Ord (f (g a)) => Ord (Compose f g a)
 
-  instance (Functor f, Functor g) => Functor (Compose f g) where
+  -- Note that in the instances below, we explicitly annotate `f` with its kind
+  -- (Type -> Type), which is not something that is done in the original base
+  -- library. This is because when singletons-th promotes instance declarations,
+  -- it omits the instance contexts. As such, the instance declarations (as well
+  -- as the associated defunctionalization symbols) would be given overly
+  -- polymorphic kinds due to kind generalization, e.g.,
+  --
+  --   instance PFunctor (Compose (f :: k -> Type) (g :: Type -> k)) where ...
+  --
+  -- Annotating `f :: Type -> Type` is a clunky but reliable way of preventing
+  -- this. See also Note [Using standalone kind signatures not present in the
+  -- base library] in Control.Monad.Singletons.Internal for a similar situation
+  -- where class definitions can become overly polymorphic unless given an
+  -- explicit kind.
+
+  instance (Functor f, Functor g) => Functor (Compose (f :: Type -> Type) g) where
       fmap f (Compose x) = Compose (fmap (fmap f) x)
       a <$ (Compose x) = Compose (fmap (a <$) x)
 
-  instance (Foldable f, Foldable g) => Foldable (Compose f g) where
+  instance (Foldable f, Foldable g) => Foldable (Compose (f :: Type -> Type) g) where
       foldMap f (Compose t) = foldMap (foldMap f) t
 
-  instance (Traversable f, Traversable g) => Traversable (Compose f g) where
+  instance (Traversable f, Traversable g) => Traversable (Compose (f :: Type -> Type) g) where
       traverse f (Compose t) = Compose <$> traverse (traverse f) t
 
-  instance (Applicative f, Applicative g) => Applicative (Compose f g) where
+  instance (Applicative f, Applicative g) => Applicative (Compose (f :: Type -> Type) g) where
       pure x = Compose (pure (pure x))
       Compose f <*> Compose x = Compose (liftA2 (<*>) f x)
       liftA2 f (Compose x) (Compose y) =
         Compose (liftA2 (liftA2 f) x y)
 
-  instance (Alternative f, Applicative g) => Alternative (Compose f g) where
+  instance (Alternative f, Applicative g) => Alternative (Compose (f :: Type -> Type) g) where
       empty = Compose empty
       Compose x <|> Compose y = Compose (x <|> y)
   |])
diff --git a/src/Data/Functor/Const/Singletons.hs b/src/Data/Functor/Const/Singletons.hs
--- a/src/Data/Functor/Const/Singletons.hs
+++ b/src/Data/Functor/Const/Singletons.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE NoNamedWildCards #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
@@ -31,73 +31,28 @@
 import Control.Monad.Singletons.Internal
 import Data.Eq.Singletons
 import Data.Foldable.Singletons
-import Data.Kind (Type)
 import Data.Monoid.Singletons
 import Data.Ord.Singletons
-import Data.Semigroup.Singletons.Internal
-import Data.Singletons
+import Data.Semigroup.Singletons.Internal.Classes
 import Data.Singletons.Base.Instances hiding (FoldlSym0, sFoldl)
 import Data.Singletons.Base.Enum
 import Data.Singletons.TH
+import Data.Singletons.TH.Options
 import GHC.Base.Singletons
   hiding ( Const, ConstSym0, ConstSym1
          , Foldr, FoldrSym0, sFoldr )
 import GHC.Num.Singletons
 import Text.Show.Singletons
 
-{-
-Const's argument `b` is poly-kinded, and as a result, we have a choice as to
-what singleton type to give it. We could use either
-
-1. type SConst :: forall {k :: Type} (a :: Type) (b :: k).    Const a b -> Type
-2. type SConst :: forall             (a :: Type) (b :: Type). Const a b -> Type
-
-Option (1) is the more permissive one, so we opt for that. However, singletons-th's
-TH machinery does not jive with this option, since the SingKind instance it
-tries to generate:
-
-  instance (SingKind a, SingKind b) => SingKind (Const a b) where
-    type Demote (Const a b) = Const (Demote a) (Demote b)
-
-Assumes that `b` is of kind Type. Until we get a more reliable story for
-poly-kinded Sing instances (see #150), we simply write the singleton type by
-hand.
+$(withOptions defaultOptions{genSingKindInsts = False}
+    (genSingletons [''Const]))
 
-Note that we cannot use genSingletons to generate this code because we
-would end up with the wrong specificity for the kind of `a` when singling the
-Const constructor. See Note [Preserve the order of type variables during
-singling] in D.S.TH.Single.Type, wrinkle 2. Similarly, we must define the
-defunctionalization symbols for the Const data constructor by hand to get the
-specificities right.
--}
-type SConst :: Const a b -> Type
-data SConst :: Const a b -> Type where
-  SConst :: forall {k} a (b :: k) (x :: a).
-            Sing x -> SConst ('Const @a @b x)
-type instance Sing = SConst
 instance SingKind a => SingKind (Const a b) where
   type Demote (Const a b) = Const (Demote a) b
   fromSing (SConst sa) = Const (fromSing sa)
   toSing (Const a) = withSomeSing a $ SomeSing . SConst
-instance SingI a => SingI ('Const a) where
-  sing = SConst sing
-instance SingI1 'Const where
-  liftSing = SConst
 
-type ConstSym0 :: a ~> Const a b
-data ConstSym0 z
-type instance Apply ConstSym0 x = 'Const x
-instance SingI ConstSym0 where
-  sing = singFun1 SConst
-
-type ConstSym1 :: a -> Const a b
-type family ConstSym1 x where
-  ConstSym1 x = 'Const x
-
 $(singletonsOnly [d|
-  getConst :: Const a b -> a
-  getConst (Const x) = x
-
   deriving instance Bounded a => Bounded (Const a b)
   deriving instance Eq      a => Eq      (Const a b)
   deriving instance Ord     a => Ord     (Const a b)
diff --git a/src/Data/Functor/Identity/Singletons.hs b/src/Data/Functor/Identity/Singletons.hs
--- a/src/Data/Functor/Identity/Singletons.hs
+++ b/src/Data/Functor/Identity/Singletons.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE NoNamedWildCards #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
@@ -27,7 +27,6 @@
   RunIdentitySym0, RunIdentitySym1
   ) where
 
-import Control.Applicative
 import Control.Monad.Singletons.Internal
 import Data.Eq.Singletons
 import Data.Foldable (Foldable(..))
@@ -35,7 +34,7 @@
 import Data.Functor.Identity
 import Data.Monoid.Singletons
 import Data.Ord.Singletons
-import Data.Semigroup.Singletons.Internal
+import Data.Semigroup.Singletons.Internal.Classes
 import Data.Singletons.Base.Instances hiding (Foldl, sFoldl)
 import Data.Singletons.Base.Enum
 import Data.Singletons.TH
diff --git a/src/Data/Functor/Product/Singletons.hs b/src/Data/Functor/Product/Singletons.hs
--- a/src/Data/Functor/Product/Singletons.hs
+++ b/src/Data/Functor/Product/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
@@ -31,53 +31,27 @@
 import Control.Monad.Singletons
 import Control.Monad.Zip
 import Control.Monad.Zip.Singletons
+import Data.Bool.Singletons
+import Data.Eq.Singletons
 import Data.Foldable.Singletons hiding (Product)
 import Data.Function.Singletons
 import Data.Functor.Product
 import Data.Kind
 import Data.Monoid.Singletons hiding (SProduct(..))
-import Data.Singletons
+import Data.Semigroup.Singletons hiding (SProduct(..))
+import Data.Singletons.Base.Instances (SList(..), (:@#@$), NilSym0)
+import Data.Ord.Singletons
 import Data.Singletons.TH
+import Data.Singletons.TH.Options
 import Data.Traversable.Singletons
 
-{-
-In order to keep the type arguments to Product poly-kinded and with inferred
-specificities, we define the singleton version of Product, as well as its
-defunctionalization symbols, by hand. This is very much in the spirit of the
-code in Data.Functor.Const.Singletons. (See the comments above SConst in that
-module for more details on this choice.)
--}
-type SProduct :: Product f g a -> Type
-data SProduct :: Product f g a -> Type where
-  SPair :: forall f g a (x :: f a) (y :: g a).
-           Sing x -> Sing y -> SProduct ('Pair @f @g @a x y)
-type instance Sing = SProduct
-instance (SingI x, SingI y) => SingI ('Pair x y) where
-  sing = SPair sing sing
-instance SingI x => SingI1 ('Pair x) where
-  liftSing = SPair sing
-instance SingI2 'Pair where
-  liftSing2 = SPair
-
-type PairSym0 :: forall f g a. f a ~> g a ~> Product f g a
-data PairSym0 z
-type instance Apply PairSym0 x = PairSym1 x
-instance SingI PairSym0 where
-  sing = singFun2 SPair
-
-type PairSym1 :: forall f g a. f a -> g a ~> Product f g a
-data PairSym1 fa z
-type instance Apply (PairSym1 x) y = 'Pair x y
-instance SingI x => SingI (PairSym1 x) where
-  sing = singFun1 $ SPair (sing @x)
-instance SingI1 PairSym1 where
-  liftSing s = singFun1 $ SPair s
-
-type PairSym2 :: forall f g a. f a -> g a -> Product f g a
-type family PairSym2 x y where
-  PairSym2 x y = 'Pair x y
+$(withOptions defaultOptions{genSingKindInsts = False}
+    (genSingletons [''Product]))
 
 $(singletonsOnly [d|
+  deriving instance (Eq (f a), Eq (g a)) => Eq (Product f g a)
+  deriving instance (Ord (f a), Ord (g a)) => Ord (Product f g a)
+
   instance (Functor f, Functor g) => Functor (Product f g) where
       fmap f (Pair x y) = Pair (fmap f x) (fmap f y)
       a <$ (Pair x y) = Pair (a <$ x) (a <$ y)
@@ -93,20 +67,44 @@
       Pair f g <*> Pair x y = Pair (f <*> x) (g <*> y)
       liftA2 f (Pair a b) (Pair x y) = Pair (liftA2 f a x) (liftA2 f b y)
 
-  instance (Alternative f, Alternative g) => Alternative (Product f g) where
-      empty = Pair empty empty
-      Pair x1 y1 <|> Pair x2 y2 = Pair (x1 <|> x2) (y1 <|> y2)
-
   instance (Monad f, Monad g) => Monad (Product f g) where
       Pair m n >>= f = Pair (m >>= fstP . f) (n >>= sndP . f)
         where
           fstP (Pair a _) = a
           sndP (Pair _ b) = b
 
-  instance (MonadPlus f, MonadPlus g) => MonadPlus (Product f g) where
-      mzero = Pair mzero mzero
-      Pair x1 y1 `mplus` Pair x2 y2 = Pair (x1 `mplus` x2) (y1 `mplus` y2)
-
   instance (MonadZip f, MonadZip g) => MonadZip (Product f g) where
       mzipWith f (Pair x1 y1) (Pair x2 y2) = Pair (mzipWith f x1 x2) (mzipWith f y1 y2)
+
+  -- Note that in the instances below, we explicitly annotate `f` with its kind
+  -- (Type -> Type), which is not something that is done in the original base
+  -- library. This is because when singletons-th promotes instance declarations,
+  -- it omits the instance contexts when generating the helper type families.
+  -- This can lead to the helper type families having overly polymorphic kinds.
+  -- For example, if the Alternative instance below lacked the explicit
+  -- (f :: Type -> Type) kind signature, the generated code would look like:
+  --
+  --   instance PAlternative (Product f g) where
+  --     type Empty = EmptyHelper
+  --     ...
+  --
+  --   type EmptyHelper :: forall f g a. Product f g a
+  --
+  -- This will result in EmptyHelper having a more polymorphic kind than
+  -- intended, since GHC will generalize EmptyHelper's kind to:
+  --
+  --   type EmptyHelper :: forall {k} (f :: k -> Type) (g :: k -> Type) (a :: k). Product f g a
+  --
+  -- Annotating `f :: Type -> Type` is a clunky but reliable way of preventing
+  -- this. See also Note [Using standalone kind signatures not present in the
+  -- base library] in Control.Monad.Singletons.Internal for a similar situation
+  -- where class definitions can become overly polymorphic unless given an
+  -- explicit kind.
+  instance (Alternative f, Alternative g) => Alternative (Product (f :: Type -> Type) g) where
+      empty = Pair empty empty
+      Pair x1 y1 <|> Pair x2 y2 = Pair (x1 <|> x2) (y1 <|> y2)
+
+  instance (MonadPlus f, MonadPlus g) => MonadPlus (Product (f :: Type -> Type) g) where
+      mzero = Pair mzero mzero
+      Pair x1 y1 `mplus` Pair x2 y2 = Pair (x1 `mplus` x2) (y1 `mplus` y2)
   |])
diff --git a/src/Data/Functor/Singletons.hs b/src/Data/Functor/Singletons.hs
--- a/src/Data/Functor/Singletons.hs
+++ b/src/Data/Functor/Singletons.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE NoNamedWildCards #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
diff --git a/src/Data/Functor/Sum/Singletons.hs b/src/Data/Functor/Sum/Singletons.hs
--- a/src/Data/Functor/Sum/Singletons.hs
+++ b/src/Data/Functor/Sum/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
@@ -26,58 +26,25 @@
   InRSym0, InRSym1,
   ) where
 
+import Data.Bool.Singletons
+import Data.Eq.Singletons
 import Data.Foldable.Singletons hiding (Sum)
 import Data.Functor.Singletons
 import Data.Functor.Sum
-import Data.Kind
-import Data.Singletons
+import Data.Ord.Singletons
+import Data.Semigroup.Singletons hiding (SSum(..))
+import Data.Singletons.Base.Instances (SList(..), (:@#@$), NilSym0)
 import Data.Singletons.TH
+import Data.Singletons.TH.Options
 import Data.Traversable.Singletons
 
-{-
-In order to keep the type arguments to Sum poly-kinded and with inferred
-specificities, we define the singleton version of Sum, as well as its
-defunctionalization symbols, by hand. This is very much in the spirit of the
-code in Data.Functor.Const.Singletons. (See the comments above SConst in that
-module for more details on this choice.)
--}
-type SSum :: Sum f g a -> Type
-data SSum :: Sum f g a -> Type where
-  SInL :: forall f g a (x :: f a).
-          Sing x -> SSum ('InL @f @g @a x)
-  SInR :: forall f g a (y :: g a).
-          Sing y -> SSum ('InR @f @g @a y)
-type instance Sing = SSum
-instance SingI x => SingI ('InL x) where
-  sing = SInL sing
-instance SingI1 'InL where
-  liftSing = SInL
-instance SingI y => SingI ('InR y) where
-  sing = SInR sing
-instance SingI1 'InR where
-  liftSing = SInR
-
-type InLSym0 :: forall f g a. f a ~> Sum f g a
-data InLSym0 z
-type instance Apply InLSym0 x = 'InL x
-instance SingI InLSym0 where
-  sing = singFun1 SInL
-
-type InLSym1 :: forall f g a. f a -> Sum f g a
-type family InLSym1 x where
-  InLSym1 x = 'InL x
-
-type InRSym0 :: forall f g a. g a ~> Sum f g a
-data InRSym0 z
-type instance Apply InRSym0 y = 'InR y
-instance SingI InRSym0 where
-  sing = singFun1 SInR
-
-type InRSym1 :: forall f g a. g a -> Sum f g a
-type family InRSym1 x where
-  InRSym1 y = 'InR y
+$(withOptions defaultOptions{genSingKindInsts = False}
+    (genSingletons [''Sum]))
 
 $(singletonsOnly [d|
+  deriving instance (Eq (f a), Eq (g a)) => Eq (Sum f g a)
+  deriving instance (Ord (f a), Ord (g a)) => Ord (Sum f g a)
+
   instance (Functor f, Functor g) => Functor (Sum f g) where
       fmap f (InL x) = InL (fmap f x)
       fmap f (InR y) = InR (fmap f y)
diff --git a/src/Data/List/NonEmpty/Singletons.hs b/src/Data/List/NonEmpty/Singletons.hs
--- a/src/Data/List/NonEmpty/Singletons.hs
+++ b/src/Data/List/NonEmpty/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
diff --git a/src/Data/List/Singletons.hs b/src/Data/List/Singletons.hs
--- a/src/Data/List/Singletons.hs
+++ b/src/Data/List/Singletons.hs
@@ -1,5 +1,3 @@
-{-# LANGUAGE ExplicitNamespaces #-}
-
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.List.Singletons
diff --git a/src/Data/List/Singletons/Internal.hs b/src/Data/List/Singletons/Internal.hs
--- a/src/Data/List/Singletons/Internal.hs
+++ b/src/Data/List/Singletons/Internal.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE NoNamedWildCards #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -O0 #-}
@@ -31,7 +31,8 @@
 import Data.Maybe
 import Data.Maybe.Singletons
 import Data.Ord.Singletons
-import Data.Semigroup.Singletons.Internal (SSemigroup(..), type (<>@#@$))
+import Data.Semigroup.Singletons.Internal.Classes (SSemigroup(..), type (<>@#@$))
+import Data.Semigroup.Singletons.Internal.Wrappers ()
 import Data.Singletons.Base.Instances
 import Data.Singletons.TH
 import Data.Tuple.Singletons
diff --git a/src/Data/List/Singletons/Internal/Disambiguation.hs b/src/Data/List/Singletons/Internal/Disambiguation.hs
--- a/src/Data/List/Singletons/Internal/Disambiguation.hs
+++ b/src/Data/List/Singletons/Internal/Disambiguation.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
@@ -20,7 +20,7 @@
 module Data.List.Singletons.Internal.Disambiguation where
 
 import Data.Eq.Singletons
-import Data.List ( foldl', inits, insert, intersperse, isPrefixOf
+import Data.List ( inits, insert, intersperse, isPrefixOf
                  , nubBy, partition, sort, sortBy, tails, transpose )
 import Data.List.Singletons.Internal
 import Data.Ord.Singletons
diff --git a/src/Data/Maybe/Singletons.hs b/src/Data/Maybe/Singletons.hs
--- a/src/Data/Maybe/Singletons.hs
+++ b/src/Data/Maybe/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/src/Data/Monoid/Singletons.hs b/src/Data/Monoid/Singletons.hs
--- a/src/Data/Monoid/Singletons.hs
+++ b/src/Data/Monoid/Singletons.hs
@@ -1,7 +1,7 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE NoNamedWildCards #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
@@ -47,7 +47,8 @@
 import Data.Ord (Down(..))
 import Data.Ord.Singletons
 import Data.Semigroup hiding (First(..), Last(..))
-import Data.Semigroup.Singletons.Internal hiding
+import Data.Semigroup.Singletons.Internal.Classes
+import Data.Semigroup.Singletons.Internal.Wrappers hiding
        (SFirst, SLast,
         FirstSym0, FirstSym1, FirstSym0KindInference,
         LastSym0,  LastSym1,  LastSym0KindInference,
diff --git a/src/Data/Ord/Singletons.hs b/src/Data/Ord/Singletons.hs
--- a/src/Data/Ord/Singletons.hs
+++ b/src/Data/Ord/Singletons.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
@@ -24,14 +24,9 @@
 
   Comparing, sComparing,
 
-  -- | 'thenCmp' returns its second argument if its first is 'EQ'; otherwise,
-  -- it returns its first argument.
-  thenCmp, ThenCmp, sThenCmp,
-
   Sing, SOrdering(..), SDown(..), GetDown, sGetDown,
 
   -- ** Defunctionalization symbols
-  ThenCmpSym0, ThenCmpSym1, ThenCmpSym2,
   LTSym0, EQSym0, GTSym0,
   CompareSym0, CompareSym1, CompareSym2,
   type (<@#@$),  type (<@#@$$),  type (<@#@$$$),
@@ -47,10 +42,10 @@
 
 import Data.Eq.Singletons
 import Data.Ord (Down(..))
+import Data.Semigroup.Singletons.Internal.Classes
 import Data.Singletons.Base.Instances
 import Data.Singletons.Base.Util
 import Data.Singletons.TH
-import Language.Haskell.TH.Syntax (thenCmp)
 
 $(singletonsOnly [d|
   class  (Eq a) => Ord a  where
@@ -89,11 +84,6 @@
   -- >   ... sortBy (comparing fst) ...
   comparing :: (Ord a) => (b -> a) -> b -> b -> Ordering
   comparing p x y = compare (p x) (p y)
-
-  thenCmp :: Ordering -> Ordering -> Ordering
-  thenCmp EQ x = x
-  thenCmp LT _ = LT
-  thenCmp GT _ = GT
   |])
 
 $(genSingletons [''Down])
@@ -103,6 +93,10 @@
 
   instance Ord a => Ord (Down a) where
       compare (Down x) (Down y) = y `compare` x
+
+  -- deriving newtype instance Semigroup a => Semigroup (Down a)
+  instance Semigroup a => Semigroup (Down a) where
+    Down a <> Down b = Down (a <> b)
   |])
 
 $(singOrdInstances basicTypes)
diff --git a/src/Data/Ord/Singletons/Disambiguation.hs b/src/Data/Ord/Singletons/Disambiguation.hs
--- a/src/Data/Ord/Singletons/Disambiguation.hs
+++ b/src/Data/Ord/Singletons/Disambiguation.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/src/Data/Proxy/Singletons.hs b/src/Data/Proxy/Singletons.hs
--- a/src/Data/Proxy/Singletons.hs
+++ b/src/Data/Proxy/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
@@ -31,17 +31,16 @@
 import Control.Monad
 import Control.Monad.Singletons.Internal
 import Data.Eq.Singletons
-import Data.Kind
 import Data.Monoid.Singletons
 import Data.Ord.Singletons
 import Data.Proxy
 import Data.Semigroup (Semigroup(..))
-import Data.Semigroup.Singletons.Internal
+import Data.Semigroup.Singletons.Internal.Classes
 import Data.Singletons.Decide
-import Data.Singletons
 import Data.Singletons.Base.Enum
 import Data.Singletons.Base.Instances
 import Data.Singletons.TH
+import Data.Singletons.TH.Options
 import Data.Type.Coercion
 import Data.Type.Equality hiding (type (==))
 import GHC.Base.Singletons
@@ -49,27 +48,16 @@
 import GHC.TypeLits.Singletons.Internal
 import Text.Show.Singletons
 
-{-
-In order to keep the type argument to Proxy poly-kinded and with an inferred
-specificity, we define the singleton version of Proxy, as well as its
-defunctionalization symbols, by hand. This is very much in the spirit of the
-code in Data.Functor.Const.Singletons. (See the comments above SConst in that
-module for more details on this choice.)
--}
-type SProxy :: Proxy t -> Type
-data SProxy :: Proxy t -> Type where
-  SProxy :: forall t. SProxy ('Proxy @t)
-type instance Sing = SProxy
+$(withOptions defaultOptions{genSingKindInsts = False}
+    (genSingletons [''Proxy]))
+
 instance SingKind (Proxy t) where
   type Demote (Proxy t) = Proxy t
   fromSing SProxy = Proxy
   toSing Proxy = SomeSing SProxy
-instance SingI 'Proxy where
-  sing = SProxy
 
-type ProxySym0 :: Proxy t
-type family ProxySym0 where
-  ProxySym0 = 'Proxy
+instance Eq (SProxy z) where
+  _ == _ = True
 
 instance SDecide (Proxy t) where
   SProxy %~ SProxy = Proved Refl
@@ -79,6 +67,9 @@
 
 instance TestCoercion SProxy where
   testCoercion = decideCoercion
+
+instance Ord (SProxy z) where
+  compare _ _ = EQ
 
 instance Show (SProxy z) where
   showsPrec _ _ = showString "SProxy"
diff --git a/src/Data/Semigroup/Singletons.hs b/src/Data/Semigroup/Singletons.hs
--- a/src/Data/Semigroup/Singletons.hs
+++ b/src/Data/Semigroup/Singletons.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE NoNamedWildCards #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
@@ -46,7 +46,6 @@
   ArgSym0, ArgSym1, ArgSym2
   ) where
 
-import Control.Applicative
 import Control.Monad.Singletons.Internal
 import Data.Eq.Singletons
 import Data.Foldable.Singletons hiding
@@ -64,7 +63,8 @@
 import Data.Ord.Singletons.Disambiguation
 import qualified Data.Semigroup as Semi (Min(..), Max(..))
 import Data.Semigroup (First(..), Last(..), WrappedMonoid(..), Arg(..))
-import Data.Semigroup.Singletons.Internal
+import Data.Semigroup.Singletons.Internal.Classes
+import Data.Semigroup.Singletons.Internal.Wrappers
 import Data.Singletons.Base.Enum
 import Data.Singletons.Base.Instances
 import Data.Singletons.Base.Util
@@ -78,6 +78,12 @@
 $(genSingletons [''Arg])
 $(showSingInstances semigroupBasicTypes)
 $(singShowInstances semigroupBasicTypes)
+
+instance Eq (SArg z) where
+  _ == _ = True
+
+instance Ord (SArg z) where
+  compare _ _ = EQ
 
 $(singletonsOnly [d|
   instance Applicative Semi.Min where
diff --git a/src/Data/Semigroup/Singletons/Internal.hs b/src/Data/Semigroup/Singletons/Internal.hs
deleted file mode 100644
--- a/src/Data/Semigroup/Singletons/Internal.hs
+++ /dev/null
@@ -1,219 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DefaultSignatures #-}
-{-# LANGUAGE NoNamedWildCards #-}
-{-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-
------------------------------------------------------------------------------
--- |
--- Module      :  Data.Semigroup.Singletons.Internal
--- Copyright   :  (C) 2018 Ryan Scott
--- License     :  BSD-style (see LICENSE)
--- Maintainer  :  Ryan Scott
--- Stability   :  experimental
--- Portability :  non-portable
---
--- Defines the promoted version of 'Semigroup', 'PSemigroup'; the
--- singleton version, 'SSemigroup'; and some @newtype@ wrappers, all
--- of which are reexported from the "Data.Semigroup" module or
--- imported directly by some other modules.
---
--- This module exists to avoid import cycles with
--- "Data.Monoid.Singletons".
---
-----------------------------------------------------------------------------
-
-module Data.Semigroup.Singletons.Internal where
-
-import Control.Monad.Singletons.Internal
-import Data.Bool.Singletons
-import Data.Eq.Singletons
-import Data.List.NonEmpty (NonEmpty(..))
-import Data.Ord (Down(..))
-import Data.Ord.Singletons hiding (MinSym0, MinSym1, MaxSym0, MaxSym1)
-import Data.Proxy
-import Data.Semigroup (Dual(..), All(..), Any(..), Sum(..), Product(..))
-import Data.Singletons
-import Data.Singletons.Base.Enum
-import Data.Singletons.Base.Instances
-import Data.Singletons.Base.Util
-import Data.Singletons.TH
-import qualified Data.Text as T
-import GHC.Base.Singletons
-import GHC.Num.Singletons
-import GHC.TypeLits (AppendSymbol, SomeSymbol(..), someSymbolVal)
-import GHC.TypeLits.Singletons.Internal
-import Unsafe.Coerce
-
-$(singletonsOnly [d|
-  -- -| The class of semigroups (types with an associative binary operation).
-  --
-  -- Instances should satisfy the associativity law:
-  --
-  --  * @x '<>' (y '<>' z) = (x '<>' y) '<>' z@
-  class Semigroup a where
-        -- -| An associative operation.
-        (<>) :: a -> a -> a
-        infixr 6 <>
-
-        -- -| Reduce a non-empty list with @\<\>@
-        --
-        -- The default definition should be sufficient, but this can be
-        -- overridden for efficiency.
-        --
-        sconcat :: NonEmpty a -> a
-        sconcat (a :| as) = go a as where
-          go :: a -> [a] -> a
-          go b (c:cs) = b <> go c cs
-          go b []     = b
-
-        {-
-        Can't single 'stimes', since there's no singled 'Integral' class.
-
-        -- -| Repeat a value @n@ times.
-        --
-        -- Given that this works on a 'Semigroup' it is allowed to fail if
-        -- you request 0 or fewer repetitions, and the default definition
-        -- will do so.
-        --
-        -- By making this a member of the class, idempotent semigroups
-        -- and monoids can upgrade this to execute in /O(1)/ by
-        -- picking @stimes = 'stimesIdempotent'@ or @stimes =
-        -- 'stimesIdempotentMonoid'@ respectively.
-        stimes :: Integral b => b -> a -> a
-        stimes = stimesDefault
-        -}
-
-
-  instance Semigroup [a] where
-        (<>) = (++)
-
-  instance Semigroup (NonEmpty a) where
-        (a :| as) <> (b :| bs) = a :| (as ++ b : bs)
-
-  instance Semigroup b => Semigroup (a -> b) where
-        f <> g = \x -> f x <> g x
-
-  instance Semigroup () where
-        _ <> _      = ()
-        sconcat _   = ()
-
-  instance (Semigroup a, Semigroup b) => Semigroup (a, b) where
-        (a,b) <> (a',b') = (a<>a',b<>b')
-
-  instance (Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) where
-        (a,b,c) <> (a',b',c') = (a<>a',b<>b',c<>c')
-
-  instance (Semigroup a, Semigroup b, Semigroup c, Semigroup d)
-         => Semigroup (a, b, c, d) where
-        (a,b,c,d) <> (a',b',c',d') = (a<>a',b<>b',c<>c',d<>d')
-
-  instance (Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e)
-         => Semigroup (a, b, c, d, e) where
-        (a,b,c,d,e) <> (a',b',c',d',e') = (a<>a',b<>b',c<>c',d<>d',e<>e')
-
-  instance Semigroup Ordering where
-    LT <> _ = LT
-    EQ <> y = y
-    GT <> _ = GT
-
-  instance Semigroup a => Semigroup (Maybe a) where
-    Nothing <> b       = b
-    a       <> Nothing = a
-    Just a  <> Just b  = Just (a <> b)
-
-  instance Semigroup (Either a b) where
-    Left _    <> b = b
-    -- a      <> _ = a
-    a@Right{} <> _ = a
-
-  instance Semigroup Void where
-    a <> _ = a
-
-  -- deriving newtype instance Semigroup a => Semigroup (Down a)
-  instance Semigroup a => Semigroup (Down a) where
-    Down a <> Down b = Down (a <> b)
-  |])
-
-$(genSingletons        semigroupBasicTypes)
-$(singBoundedInstances semigroupBasicTypes)
-$(singEqInstances      semigroupBasicTypes)
-$(singDecideInstances  semigroupBasicTypes)
-$(singOrdInstances     semigroupBasicTypes)
-
-$(singletonsOnly [d|
-  instance Applicative Dual where
-    pure = Dual
-    Dual f <*> Dual x = Dual (f x)
-
-  deriving instance Functor Dual
-
-  instance Monad Dual where
-    Dual a >>= k = k a
-
-  instance Semigroup a => Semigroup (Dual a) where
-          Dual a <> Dual b = Dual (b <> a)
-
-  instance Semigroup All where
-          All a <> All b = All (a && b)
-
-  instance Semigroup Any where
-          Any a <> Any b = Any (a || b)
-
-  instance Applicative Sum where
-    pure = Sum
-    Sum f <*> Sum x = Sum (f x)
-
-  deriving instance Functor Sum
-
-  instance Monad Sum where
-    Sum a >>= k = k a
-
-  instance Num a => Semigroup (Sum a) where
-          Sum a <> Sum b = Sum (a + b)
-
-  -- deriving newtype instance Num a => Num (Sum a)
-  instance Num a => Num (Sum a) where
-      Sum a + Sum b = Sum (a + b)
-      Sum a - Sum b = Sum (a - b)
-      Sum a * Sum b = Sum (a * b)
-      negate (Sum a) = Sum (negate a)
-      abs    (Sum a) = Sum (abs a)
-      signum (Sum a) = Sum (signum a)
-      fromInteger n  = Sum (fromInteger n)
-
-  instance Applicative Product where
-    pure = Product
-    Product f <*> Product x = Product (f x)
-
-  deriving instance Functor Product
-
-  instance Monad Product where
-    Product a >>= k = k a
-
-  instance Num a => Semigroup (Product a) where
-          Product a <> Product b = Product (a * b)
-
-  -- deriving newtype instance Num a => Num (Product a)
-  instance Num a => Num (Product a) where
-      Product a + Product b = Product (a + b)
-      Product a - Product b = Product (a - b)
-      Product a * Product b = Product (a * b)
-      negate (Product a) = Product (negate a)
-      abs    (Product a) = Product (abs a)
-      signum (Product a) = Product (signum a)
-      fromInteger n      = Product (fromInteger n)
-  |])
-
-instance PSemigroup Symbol where
-  type a <> b = AppendSymbol a b
-
-instance SSemigroup Symbol where
-  sa %<> sb =
-    let a  = fromSing sa
-        b  = fromSing sb
-        ex = someSymbolVal $ T.unpack $ a <> b
-    in case ex of
-         SomeSymbol (_ :: Proxy ab) -> unsafeCoerce (SSym :: Sing ab)
diff --git a/src/Data/Semigroup/Singletons/Internal/Classes.hs b/src/Data/Semigroup/Singletons/Internal/Classes.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Semigroup/Singletons/Internal/Classes.hs
@@ -0,0 +1,117 @@
+{-# LANGUAGE DefaultSignatures #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Semigroup.Singletons.Internal.Classes
+-- Copyright   :  (C) 2018 Ryan Scott
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Ryan Scott
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Defines the promoted version of 'Semigroup', 'PSemigroup'; the
+-- singleton version, 'SSemigroup'; and instances thereof for various data
+-- types in @base@. These are reexported from the "Data.Semigroup" module or
+-- imported directly by some other modules.
+--
+-- This module exists to avoid import cycles with
+-- "Data.Ord.Singletons".
+--
+----------------------------------------------------------------------------
+
+module Data.Semigroup.Singletons.Internal.Classes where
+
+import Data.List.NonEmpty (NonEmpty(..))
+import Data.Singletons.Base.Instances
+import Data.Singletons.TH
+import GHC.Base.Singletons
+
+$(singletonsOnly [d|
+  -- -| The class of semigroups (types with an associative binary operation).
+  --
+  -- Instances should satisfy the associativity law:
+  --
+  --  * @x '<>' (y '<>' z) = (x '<>' y) '<>' z@
+  class Semigroup a where
+        -- -| An associative operation.
+        (<>) :: a -> a -> a
+        infixr 6 <>
+
+        -- -| Reduce a non-empty list with @\<\>@
+        --
+        -- The default definition should be sufficient, but this can be
+        -- overridden for efficiency.
+        --
+        sconcat :: NonEmpty a -> a
+        sconcat (a :| as) = go a as where
+          go :: a -> [a] -> a
+          go b (c:cs) = b <> go c cs
+          go b []     = b
+
+        {-
+        Can't single 'stimes', since there's no singled 'Integral' class.
+
+        -- -| Repeat a value @n@ times.
+        --
+        -- Given that this works on a 'Semigroup' it is allowed to fail if
+        -- you request 0 or fewer repetitions, and the default definition
+        -- will do so.
+        --
+        -- By making this a member of the class, idempotent semigroups
+        -- and monoids can upgrade this to execute in /O(1)/ by
+        -- picking @stimes = 'stimesIdempotent'@ or @stimes =
+        -- 'stimesIdempotentMonoid'@ respectively.
+        stimes :: Integral b => b -> a -> a
+        stimes = stimesDefault
+        -}
+
+
+  instance Semigroup [a] where
+        (<>) = (++)
+
+  instance Semigroup (NonEmpty a) where
+        (a :| as) <> (b :| bs) = a :| (as ++ b : bs)
+
+  instance Semigroup b => Semigroup (a -> b) where
+        f <> g = \x -> f x <> g x
+
+  instance Semigroup () where
+        _ <> _      = ()
+        sconcat _   = ()
+
+  instance (Semigroup a, Semigroup b) => Semigroup (a, b) where
+        (a,b) <> (a',b') = (a<>a',b<>b')
+
+  instance (Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) where
+        (a,b,c) <> (a',b',c') = (a<>a',b<>b',c<>c')
+
+  instance (Semigroup a, Semigroup b, Semigroup c, Semigroup d)
+         => Semigroup (a, b, c, d) where
+        (a,b,c,d) <> (a',b',c',d') = (a<>a',b<>b',c<>c',d<>d')
+
+  instance (Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e)
+         => Semigroup (a, b, c, d, e) where
+        (a,b,c,d,e) <> (a',b',c',d',e') = (a<>a',b<>b',c<>c',d<>d',e<>e')
+
+  instance Semigroup Ordering where
+    LT <> _ = LT
+    EQ <> y = y
+    GT <> _ = GT
+
+  instance Semigroup a => Semigroup (Maybe a) where
+    Nothing <> b       = b
+    a       <> Nothing = a
+    Just a  <> Just b  = Just (a <> b)
+
+  instance Semigroup (Either a b) where
+    Left _    <> b = b
+    -- a      <> _ = a
+    a@Right{} <> _ = a
+
+  instance Semigroup Void where
+    a <> _ = a
+  |])
diff --git a/src/Data/Semigroup/Singletons/Internal/Disambiguation.hs b/src/Data/Semigroup/Singletons/Internal/Disambiguation.hs
--- a/src/Data/Semigroup/Singletons/Internal/Disambiguation.hs
+++ b/src/Data/Semigroup/Singletons/Internal/Disambiguation.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
@@ -21,7 +21,7 @@
 module Data.Semigroup.Singletons.Internal.Disambiguation where
 
 import Data.Semigroup
-import Data.Semigroup.Singletons.Internal
+import Data.Semigroup.Singletons.Internal.Wrappers
 import Data.Singletons.TH
 
 -- We need these in Data.Foldable.Singletons, as we need to promote
diff --git a/src/Data/Semigroup/Singletons/Internal/Wrappers.hs b/src/Data/Semigroup/Singletons/Internal/Wrappers.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Semigroup/Singletons/Internal/Wrappers.hs
@@ -0,0 +1,108 @@
+{-# LANGUAGE NoNamedWildCards #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# OPTIONS_GHC -Wno-orphans #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Semigroup.Singletons.Internal.Wrappers
+-- Copyright   :  (C) 2018 Ryan Scott
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Ryan Scott
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Defines the promoted and singled versions of the @newtype@ wrappers from
+-- "Data.Semigroup", all of which are reexported from the "Data.Semigroup"
+-- module or imported directly by some other modules.
+--
+-- This module exists to avoid import cycles with
+-- "Data.Monoid.Singletons".
+--
+----------------------------------------------------------------------------
+
+module Data.Semigroup.Singletons.Internal.Wrappers where
+
+import Control.Monad.Singletons.Internal
+import Data.Bool.Singletons
+import Data.Eq.Singletons
+import Data.Ord.Singletons hiding (MinSym0, MinSym1, MaxSym0, MaxSym1)
+import Data.Semigroup (Dual(..), All(..), Any(..), Sum(..), Product(..))
+import Data.Semigroup.Singletons.Internal.Classes
+import Data.Singletons.Base.Enum
+import Data.Singletons.Base.Instances
+import Data.Singletons.Base.Util
+import Data.Singletons.TH
+import GHC.Num.Singletons
+
+$(genSingletons        semigroupBasicTypes)
+$(singBoundedInstances semigroupBasicTypes)
+$(singEqInstances      semigroupBasicTypes)
+$(singDecideInstances  semigroupBasicTypes)
+$(singOrdInstances     semigroupBasicTypes)
+
+$(singletonsOnly [d|
+  instance Applicative Dual where
+    pure = Dual
+    Dual f <*> Dual x = Dual (f x)
+
+  deriving instance Functor Dual
+
+  instance Monad Dual where
+    Dual a >>= k = k a
+
+  instance Semigroup a => Semigroup (Dual a) where
+          Dual a <> Dual b = Dual (b <> a)
+
+  instance Semigroup All where
+          All a <> All b = All (a && b)
+
+  instance Semigroup Any where
+          Any a <> Any b = Any (a || b)
+
+  instance Applicative Sum where
+    pure = Sum
+    Sum f <*> Sum x = Sum (f x)
+
+  deriving instance Functor Sum
+
+  instance Monad Sum where
+    Sum a >>= k = k a
+
+  instance Num a => Semigroup (Sum a) where
+          Sum a <> Sum b = Sum (a + b)
+
+  -- deriving newtype instance Num a => Num (Sum a)
+  instance Num a => Num (Sum a) where
+      Sum a + Sum b = Sum (a + b)
+      Sum a - Sum b = Sum (a - b)
+      Sum a * Sum b = Sum (a * b)
+      negate (Sum a) = Sum (negate a)
+      abs    (Sum a) = Sum (abs a)
+      signum (Sum a) = Sum (signum a)
+      fromInteger n  = Sum (fromInteger n)
+
+  instance Applicative Product where
+    pure = Product
+    Product f <*> Product x = Product (f x)
+
+  deriving instance Functor Product
+
+  instance Monad Product where
+    Product a >>= k = k a
+
+  instance Num a => Semigroup (Product a) where
+          Product a <> Product b = Product (a * b)
+
+  -- deriving newtype instance Num a => Num (Product a)
+  instance Num a => Num (Product a) where
+      Product a + Product b = Product (a + b)
+      Product a - Product b = Product (a - b)
+      Product a * Product b = Product (a * b)
+      negate (Product a) = Product (negate a)
+      abs    (Product a) = Product (abs a)
+      signum (Product a) = Product (signum a)
+      fromInteger n      = Product (fromInteger n)
+  |])
diff --git a/src/Data/Singletons/Base/Enum.hs b/src/Data/Singletons/Base/Enum.hs
--- a/src/Data/Singletons/Base/Enum.hs
+++ b/src/Data/Singletons/Base/Enum.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/src/Data/Singletons/Base/Instances.hs b/src/Data/Singletons/Base/Instances.hs
--- a/src/Data/Singletons/Base/Instances.hs
+++ b/src/Data/Singletons/Base/Instances.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
diff --git a/src/Data/Singletons/Base/PolyError.hs b/src/Data/Singletons/Base/PolyError.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Singletons/Base/PolyError.hs
@@ -0,0 +1,28 @@
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Singletons.Base.TypeError
+-- Copyright   :  (C) 2023 Ryan Scott
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Ryan Scott
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Defines a replacement for the promoted @Error@ function whose argument is
+-- kind-polymorphic.
+--
+----------------------------------------------------------------------------
+module Data.Singletons.Base.PolyError (PolyError) where
+
+import Data.Singletons.TH
+
+-- | Like @Error@ from "GHC.TypeLits.Singletons", but with an argument that is
+-- generalized to be kind-polymorphic. This allows passing additional
+-- information to the error besides raw @Symbol@s.
+type PolyError :: a -> b
+type family PolyError (arg :: a) :: b where {}
+$(genDefunSymbols [''PolyError])
diff --git a/src/Data/Singletons/Base/SomeSing.hs b/src/Data/Singletons/Base/SomeSing.hs
--- a/src/Data/Singletons/Base/SomeSing.hs
+++ b/src/Data/Singletons/Base/SomeSing.hs
@@ -1,5 +1,3 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE GADTs #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
 
 -----------------------------------------------------------------------------
diff --git a/src/Data/Singletons/Base/TH.hs b/src/Data/Singletons/Base/TH.hs
--- a/src/Data/Singletons/Base/TH.hs
+++ b/src/Data/Singletons/Base/TH.hs
@@ -1,5 +1,3 @@
-{-# LANGUAGE ExplicitNamespaces #-}
-
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Singletons.Base.TH
@@ -59,7 +57,7 @@
   -- so they must be in scope.
 
   PEq(..), If, sIf, type (&&), (%&&), SEq(..),
-  POrd(..), SOrd(..), ThenCmp, sThenCmp,
+  POrd(..), SOrd(..),
   SDecide(..), (:~:)(..), Void, Refuted, Decision(..),
   PBounded(..), SBounded(..),
   PEnum(FromEnum, ToEnum), SEnum(sFromEnum, sToEnum),
@@ -68,7 +66,9 @@
   ShowChar, sShowChar, ShowCommaSpace, sShowCommaSpace,
   FromInteger, sFromInteger, Negate, sNegate,
   PFunctor(..), SFunctor(..),
-  PFoldable(..), SFoldable(..), PMonoid(..), SMonoid(..),
+  PFoldable(..), SFoldable(..),
+  PSemigroup(..), SSemigroup(..),
+  PMonoid(..), SMonoid(..),
   PTraversable(..), STraversable(..), PApplicative(..), SApplicative(..),
   type (.), (%.),
 
@@ -88,7 +88,6 @@
   Tuple6Sym0, Tuple6Sym1, Tuple6Sym2, Tuple6Sym3, Tuple6Sym4, Tuple6Sym5, Tuple6Sym6,
   Tuple7Sym0, Tuple7Sym1, Tuple7Sym2, Tuple7Sym3, Tuple7Sym4, Tuple7Sym5, Tuple7Sym6, Tuple7Sym7,
   CompareSym0, CompareSym1, CompareSym2,
-  ThenCmpSym0, ThenCmpSym1, ThenCmpSym2,
   FoldlSym0, FoldlSym1, FoldlSym2, FoldlSym3,
   MinBoundSym0, MaxBoundSym0,
   ShowsPrecSym0, ShowsPrecSym1, ShowsPrecSym2, ShowsPrecSym3,
@@ -103,6 +102,7 @@
   FmapSym0, FmapSym1, FmapSym2,
   type (<$@#@$),  type (<$@#@$$),  type (<$@#@$$$),
   FoldMapSym0, FoldMapSym1, FoldMapSym2,
+  type (<>@#@$), type (<>@#@$$), type (<>@#@$$$),
   MemptySym0,
   MappendSym0, MappendSym1, MappendSym2,
   FoldrSym0, FoldrSym1, FoldrSym2, FoldrSym3,
@@ -124,6 +124,9 @@
 import Data.Functor.Singletons hiding (Void)
 import Data.Monoid.Singletons
 import Data.Ord.Singletons
+import Data.Semigroup.Singletons
+       ( PSemigroup(..), SSemigroup(..)
+       , type (<>@#@$), type (<>@#@$$), type (<>@#@$$$) )
 import Data.Singletons
 import Data.Singletons.Base.Enum
 import Data.Singletons.Base.Instances
diff --git a/src/Data/Singletons/Base/TypeError.hs b/src/Data/Singletons/Base/TypeError.hs
--- a/src/Data/Singletons/Base/TypeError.hs
+++ b/src/Data/Singletons/Base/TypeError.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
@@ -81,7 +81,7 @@
 infixl 6 :%<>:
 infixl 5 :%$$:
 
-type instance Sing = SErrorMessage
+type instance Sing @PErrorMessage = SErrorMessage
 
 instance SingKind PErrorMessage where
   type Demote PErrorMessage = ErrorMessage
diff --git a/src/Data/String/Singletons.hs b/src/Data/String/Singletons.hs
--- a/src/Data/String/Singletons.hs
+++ b/src/Data/String/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/src/Data/Traversable/Singletons.hs b/src/Data/Traversable/Singletons.hs
--- a/src/Data/Traversable/Singletons.hs
+++ b/src/Data/Traversable/Singletons.hs
@@ -1,7 +1,7 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE NoNamedWildCards #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
@@ -63,7 +63,7 @@
 type SStateL :: forall s a. StateL s a -> Type
 data SStateL state where
   SStateL :: Sing x -> SStateL ('StateL x)
-type instance Sing = SStateL
+type instance Sing @(StateL s a) = SStateL
 type StateLSym0 :: forall s a. (s ~> (s, a)) ~> StateL s a
 data StateLSym0 z
 type instance Apply StateLSym0 x = 'StateL x
@@ -73,7 +73,7 @@
 type SStateR :: forall s a. StateR s a -> Type
 data SStateR state where
   SStateR :: Sing x -> SStateR ('StateR x)
-type instance Sing = SStateR
+type instance Sing @(StateR s a) = SStateR
 type StateRSym0 :: forall s a. (s ~> (s, a)) ~> StateR s a
 data StateRSym0 z
 type instance Apply StateRSym0 x = 'StateR x
@@ -170,6 +170,10 @@
   --    equivalent to traversal with a constant applicative functor
   --    ('foldMapDefault').
   --
+
+  -- See Note [Using standalone kind signatures not present in the base library]
+  -- in Control.Monad.Singletons.Internal.
+  type Traversable :: (Type -> Type) -> Constraint
   class (Functor t, Foldable t) => Traversable t where
       -- {-# MINIMAL traverse | sequenceA #-}
 
diff --git a/src/Data/Tuple/Singletons.hs b/src/Data/Tuple/Singletons.hs
--- a/src/Data/Tuple/Singletons.hs
+++ b/src/Data/Tuple/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/src/Data/Void/Singletons.hs b/src/Data/Void/Singletons.hs
--- a/src/Data/Void/Singletons.hs
+++ b/src/Data/Void/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/src/GHC/Base/Singletons.hs b/src/GHC/Base/Singletons.hs
--- a/src/GHC/Base/Singletons.hs
+++ b/src/GHC/Base/Singletons.hs
@@ -1,5 +1,5 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/src/GHC/Num/Singletons.hs b/src/GHC/Num/Singletons.hs
--- a/src/GHC/Num/Singletons.hs
+++ b/src/GHC/Num/Singletons.hs
@@ -1,7 +1,7 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE NoStarIsType #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
@@ -43,7 +43,6 @@
 import Data.Singletons.TH
 import GHC.TypeLits.Singletons.Internal
 import qualified GHC.TypeNats as TN
-import GHC.TypeNats (SomeNat(..), someNatVal)
 import Unsafe.Coerce
 
 $(singletonsOnly [d|
@@ -108,26 +107,17 @@
   sa %+ sb =
     let a = fromSing sa
         b = fromSing sb
-        ex = someNatVal (a + b)
-    in
-    case ex of
-      SomeNat (_ :: Proxy ab) -> unsafeCoerce (SNat :: Sing ab)
+    in TN.withSomeSNat (a + b) unsafeCoerce
 
   sa %- sb =
     let a = fromSing sa
         b = fromSing sb
-        ex = someNatVal (a - b)
-    in
-    case ex of
-      SomeNat (_ :: Proxy ab) -> unsafeCoerce (SNat :: Sing ab)
+    in TN.withSomeSNat (a - b) unsafeCoerce
 
   sa %* sb =
     let a = fromSing sa
         b = fromSing sb
-        ex = someNatVal (a * b)
-    in
-    case ex of
-      SomeNat (_ :: Proxy ab) -> unsafeCoerce (SNat :: Sing ab)
+    in TN.withSomeSNat (a * b) unsafeCoerce
 
   sNegate _ = error "Cannot call sNegate on a natural number singleton."
 
diff --git a/src/GHC/TypeLits/Singletons.hs b/src/GHC/TypeLits/Singletons.hs
--- a/src/GHC/TypeLits/Singletons.hs
+++ b/src/GHC/TypeLits/Singletons.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
@@ -20,7 +20,10 @@
 
 module GHC.TypeLits.Singletons (
   Natural, Symbol, Char,
-  Sing, SNat(..), SSymbol(..), SChar(..),
+  Sing,
+  SNat, data SNat,
+  SSymbol, data SSymbol, data SSym,
+  SChar, data SChar,
   withKnownNat, withKnownSymbol, withKnownChar,
   Error, sError,
   ErrorWithoutStackTrace, sErrorWithoutStackTrace,
@@ -70,11 +73,11 @@
 import Data.String (IsString(..))
 import qualified Data.Text as T
 import Data.Tuple.Singletons
-import GHC.TypeLits ( CharToNat, ConsSymbol, NatToChar, SomeChar(..)
-                    , SomeSymbol(..), UnconsSymbol, someCharVal, someSymbolVal )
+import GHC.TypeLits ( CharToNat, ConsSymbol, NatToChar, UnconsSymbol
+                    , withSomeSChar, withSomeSSymbol )
 import GHC.TypeLits.Singletons.Internal
 import qualified GHC.TypeNats as TN
-import GHC.TypeNats (Div, Mod, SomeNat(..))
+import GHC.TypeNats (Div, Mod)
 import Unsafe.Coerce
 
 -- | This bogus instance is helpful for people who want to define
@@ -132,22 +135,19 @@
 
 sLog2 :: Sing x -> Sing (TN.Log2 x)
 sLog2 sx =
-    let x   = fromSing sx
+    let x = fromSing sx
     in case x of
          0 -> error "log2 of 0"
-         _ -> case TN.someNatVal (genLog2 x) of
-                SomeNat (_ :: Proxy res) -> unsafeCoerce (SNat :: Sing res)
+         _ -> TN.withSomeSNat (genLog2 x) unsafeCoerce
 $(genDefunSymbols [''TN.Log2])
 instance SingI Log2Sym0 where
   sing = singFun1 sLog2
 
 sDiv :: Sing x -> Sing y -> Sing (Div x y)
 sDiv sx sy =
-    let x   = fromSing sx
-        y   = fromSing sy
-        res = TN.someNatVal (x `div` y)
-    in case res of
-         SomeNat (_ :: Proxy res) -> unsafeCoerce (SNat :: Sing res)
+    let x = fromSing sx
+        y = fromSing sy
+    in TN.withSomeSNat (x `div` y) unsafeCoerce
 infixl 7 `sDiv`
 $(genDefunSymbols [''Div])
 instance SingI DivSym0 where
@@ -159,11 +159,9 @@
 
 sMod :: Sing x -> Sing y -> Sing (Mod x y)
 sMod sx sy =
-    let x   = fromSing sx
-        y   = fromSing sy
-        res = TN.someNatVal (x `mod` y)
-    in case res of
-         SomeNat (_ :: Proxy res) -> unsafeCoerce (SNat :: Sing res)
+    let x = fromSing sx
+        y = fromSing sy
+    in TN.withSomeSNat (x `mod` y) unsafeCoerce
 infixl 7 `sMod`
 $(genDefunSymbols [''Mod])
 instance SingI ModSym0 where
@@ -194,11 +192,9 @@
     let x     = fromSing sx
         y     = fromSing sy
         (q,r) = x `divMod` y
-        qRes  = TN.someNatVal q
-        rRes  = TN.someNatVal r
-    in case (qRes, rRes) of
-         (SomeNat (_ :: Proxy q), SomeNat (_ :: Proxy r))
-           -> unsafeCoerce (STuple2 (SNat :: Sing q) (SNat :: Sing r))
+    in TN.withSomeSNat q $ \sq ->
+       TN.withSomeSNat r $ \sr ->
+       unsafeCoerce (STuple2 sq sr)
 
 sQuotRem :: Sing x -> Sing y -> Sing (QuotRem x y)
 sQuotRem = sDivMod
@@ -216,11 +212,9 @@
 
 sConsSymbol :: Sing x -> Sing y -> Sing (ConsSymbol x y)
 sConsSymbol sx sy =
-    let x   = fromSing sx
-        y   = T.unpack (fromSing sy)
-        res = someSymbolVal (consSymbol x y)
-    in case res of
-         SomeSymbol (_ :: Proxy res) -> unsafeCoerce (SSym :: Sing res)
+    let x = fromSing sx
+        y = T.unpack (fromSing sy)
+    in withSomeSSymbol (consSymbol x y) unsafeCoerce
 $(genDefunSymbols [''ConsSymbol])
 instance SingI ConsSymbolSym0 where
   sing = singFun2 sConsSymbol
@@ -247,10 +241,8 @@
 
 sCharToNat :: Sing x -> Sing (CharToNat x)
 sCharToNat sx =
-    let x   = fromSing sx
-        res = TN.someNatVal (charToNat x)
-    in case res of
-         SomeNat (_ :: Proxy res) -> unsafeCoerce (SNat :: Sing res)
+    let x = fromSing sx
+    in TN.withSomeSNat (charToNat x) unsafeCoerce
 $(genDefunSymbols [''CharToNat])
 instance SingI CharToNatSym0 where
   sing = singFun1 sCharToNat
@@ -260,10 +252,8 @@
 
 sNatToChar :: Sing x -> Sing (NatToChar x)
 sNatToChar sx =
-    let x   = fromSing sx
-        res = someCharVal (natToChar x)
-    in case res of
-         SomeChar (_ :: Proxy res) -> unsafeCoerce (SChar :: Sing res)
+    let x = fromSing sx
+    in withSomeSChar (natToChar x) unsafeCoerce
 $(genDefunSymbols [''NatToChar])
 instance SingI NatToCharSym0 where
   sing = singFun1 sNatToChar
diff --git a/src/GHC/TypeLits/Singletons/Internal.hs b/src/GHC/TypeLits/Singletons/Internal.hs
--- a/src/GHC/TypeLits/Singletons/Internal.hs
+++ b/src/GHC/TypeLits/Singletons/Internal.hs
@@ -1,5 +1,6 @@
-{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
@@ -13,7 +14,7 @@
 -- Stability   :  experimental
 -- Portability :  non-portable
 --
--- Defines and exports singletons useful for the 'Natural', 'Symbol', and
+-- Defines and exports singletons useful for the 'Natural', 'TL.Symbol', and
 -- 'Char' kinds. This exports the internal, unsafe constructors. Use import
 -- "GHC.TypeLits.Singletons" for a safe interface.
 --
@@ -22,15 +23,17 @@
 module GHC.TypeLits.Singletons.Internal (
   Sing,
 
-  Natural, Symbol, Char,
-  SNat(..), SSymbol(..), SChar(..),
-  withKnownNat, withKnownSymbol, withKnownChar,
+  Natural, TL.Symbol, Char,
+  TN.SNat, data TN.SNat,
+  TL.SSymbol, data TL.SSymbol, data SSym,
+  TL.SChar, data TL.SChar,
+  TN.withKnownNat, TL.withKnownSymbol, TL.withKnownChar,
   Error, sError,
   ErrorWithoutStackTrace, sErrorWithoutStackTrace,
   Undefined, sUndefined,
-  KnownNat, TN.natVal, KnownSymbol, symbolVal, KnownChar, charVal,
-  type (^), (%^),
-  type (<=?), (%<=?),
+  TL.KnownNat, TN.natVal, TL.KnownSymbol, TL.symbolVal, TL.KnownChar, TL.charVal,
+  type (TN.^), (%^),
+  type (TN.<=?), (%<=?),
 
   -- * Defunctionalization symbols
   ErrorSym0, ErrorSym1,
@@ -42,15 +45,16 @@
 
 import Data.Bool.Singletons
 import Data.Eq.Singletons
-import Data.Kind
 import Data.Ord.Singletons as O
+import Data.Semigroup.Singletons.Internal.Classes
 import Data.Singletons
 import Data.Singletons.Decide
 import Data.Singletons.TH
-import GHC.Show (appPrec, appPrec1)
+import Data.Type.Equality (TestEquality(..))
 import GHC.Stack (HasCallStack)
-import GHC.TypeLits as TL
+import qualified GHC.TypeLits as TL
 import qualified GHC.TypeNats as TN
+import Numeric.Natural (Natural)
 import Unsafe.Coerce
 
 import qualified Data.Text as T
@@ -60,65 +64,64 @@
 ---- TypeLits singletons ---------------------------------------------
 ----------------------------------------------------------------------
 
-type SNat :: Natural -> Type
-data SNat (n :: Natural) = KnownNat n => SNat
-type instance Sing = SNat
+-- SNat
+type instance Sing @Natural = TN.SNat
 
-instance KnownNat n => SingI n where
-  sing = SNat
+instance TN.KnownNat n => SingI n where
+  sing = TN.natSing
 
 instance SingKind Natural where
   type Demote Natural = Natural
-  fromSing (SNat :: Sing n) = TN.natVal (Proxy :: Proxy n)
-  toSing n = case TN.someNatVal n of
-               SomeNat (_ :: Proxy n) -> SomeSing (SNat :: Sing n)
+  fromSing = TN.fromSNat
+  toSing n = TN.withSomeSNat n SomeSing
 
-type SSymbol :: Symbol -> Type
-data SSymbol (n :: Symbol) = KnownSymbol n => SSym
-type instance Sing = SSymbol
+-- STL.Symbol
+type instance Sing @TL.Symbol = TL.SSymbol
 
-instance KnownSymbol n => SingI n where
-  sing = SSym
+-- | An alias for the 'TL.SSymbol' pattern synonym.
+pattern SSym :: forall s. () => TL.KnownSymbol s => TL.SSymbol s
+pattern SSym = TL.SSymbol
+{-# COMPLETE SSym #-}
 
-instance SingKind Symbol where
-  type Demote Symbol = Text
-  fromSing (SSym :: Sing n) = T.pack (symbolVal (Proxy :: Proxy n))
-  toSing s = case someSymbolVal (T.unpack s) of
-               SomeSymbol (_ :: Proxy n) -> SomeSing (SSym :: Sing n)
+instance TL.KnownSymbol n => SingI n where
+  sing = TL.symbolSing
 
-type SChar :: Char -> Type
-data SChar (c :: Char) = KnownChar c => SChar
-type instance Sing = SChar
+instance SingKind TL.Symbol where
+  type Demote TL.Symbol = Text
+  fromSing = T.pack . TL.fromSSymbol
+  toSing s = TL.withSomeSSymbol (T.unpack s) SomeSing
 
-instance KnownChar c => SingI c where
-  sing = SChar
+-- SChar
+type instance Sing @Char = TL.SChar
 
+instance TL.KnownChar c => SingI c where
+  sing = TL.charSing
+
 instance SingKind Char where
   type Demote Char = Char
-  fromSing (SChar :: Sing c) = charVal (Proxy :: Proxy c)
-  toSing sc = case someCharVal sc of
-                SomeChar (_ :: Proxy c) -> SomeSing (SChar :: Sing c)
+  fromSing = TL.fromSChar
+  toSing c = TL.withSomeSChar c SomeSing
 
 -- SDecide instances:
 instance SDecide Natural where
-  (SNat :: Sing n) %~ (SNat :: Sing m)
-    | Just r <- TN.sameNat (Proxy :: Proxy n) (Proxy :: Proxy m)
+  sn %~ sm
+    | Just r <- testEquality sn sm
     = Proved r
     | otherwise
     = Disproved (\Refl -> error errStr)
     where errStr = "Broken Natural singletons"
 
-instance SDecide Symbol where
-  (SSym :: Sing n) %~ (SSym :: Sing m)
-    | Just r <- sameSymbol (Proxy :: Proxy n) (Proxy :: Proxy m)
+instance SDecide TL.Symbol where
+  sn %~ sm
+    | Just r <- testEquality sn sm
     = Proved r
     | otherwise
     = Disproved (\Refl -> error errStr)
-    where errStr = "Broken Symbol singletons"
+    where errStr = "Broken TL.Symbol singletons"
 
 instance SDecide Char where
-  (SChar :: Sing n) %~ (SChar :: Sing m)
-    | Just r <- sameChar (Proxy :: Proxy n) (Proxy :: Proxy m)
+  sn %~ sm
+    | Just r <- testEquality sn sm
     = Proved r
     | otherwise
     = Disproved (\Refl -> error errStr)
@@ -127,27 +130,27 @@
 -- PEq instances
 instance PEq Natural where
   type x == y = DefaultEq x y
-instance PEq Symbol where
+instance PEq TL.Symbol where
   type x == y = DefaultEq x y
 instance PEq Char where
   type x == y = DefaultEq x y
 
 -- need SEq instances for TypeLits kinds
 instance SEq Natural where
-  (SNat :: Sing n) %== (SNat :: Sing m)
-    = case sameNat (Proxy :: Proxy n) (Proxy :: Proxy m) of
+  sn %== sm
+    = case testEquality sn sm of
         Just Refl -> STrue
         Nothing   -> unsafeCoerce SFalse
 
-instance SEq Symbol where
-  (SSym :: Sing n) %== (SSym :: Sing m)
-    = case sameSymbol (Proxy :: Proxy n) (Proxy :: Proxy m) of
+instance SEq TL.Symbol where
+  sn %== sm
+    = case testEquality sn sm of
         Just Refl -> STrue
         Nothing   -> unsafeCoerce SFalse
 
 instance SEq Char where
-  (SChar :: Sing n) %== (SChar :: Sing m)
-    = case sameChar (Proxy :: Proxy n) (Proxy :: Proxy m) of
+  sn %== sm
+    = case testEquality sn sm of
         Just Refl -> STrue
         Nothing   -> unsafeCoerce SFalse
 
@@ -155,8 +158,8 @@
 instance POrd Natural where
   type (a :: Natural) `Compare` (b :: Natural) = a `TN.CmpNat` b
 
-instance POrd Symbol where
-  type (a :: Symbol) `Compare` (b :: Symbol) = a `TL.CmpSymbol` b
+instance POrd TL.Symbol where
+  type (a :: TL.Symbol) `Compare` (b :: TL.Symbol) = a `TL.CmpSymbol` b
 
 instance POrd Char where
   type (a :: Char) `Compare` (b :: Char) = a `TL.CmpChar` b
@@ -168,7 +171,7 @@
                      EQ -> unsafeCoerce SEQ
                      GT -> unsafeCoerce SGT
 
-instance SOrd Symbol where
+instance SOrd TL.Symbol where
   a `sCompare` b = case fromSing a `compare` fromSing b of
                      LT -> unsafeCoerce SLT
                      EQ -> unsafeCoerce SEQ
@@ -180,98 +183,73 @@
                      EQ -> unsafeCoerce SEQ
                      GT -> unsafeCoerce SGT
 
--- Show instances
-
--- These are a bit special because the singleton constructor does not uniquely
--- determine the type being used in the constructor's return type (e.g., all Naturals
--- have the same singleton constructor, SNat). To compensate for this, we display
--- the type being used using visible type application. (Thanks to @cumber on #179
--- for suggesting this implementation.)
+-- PSemigroup instance
 
-instance Show (SNat n) where
-  showsPrec p n@SNat
-    = showParen (p > appPrec)
-      ( showString "SNat @"
-        . showsPrec appPrec1 (TN.natVal n)
-      )
+instance PSemigroup TL.Symbol where
+  type a <> b = TL.AppendSymbol a b
 
-instance Show (SSymbol s) where
-  showsPrec p s@SSym
-    = showParen (p > appPrec)
-      ( showString "SSym @"
-        . showsPrec appPrec1 (symbolVal s)
-      )
+-- SSemigroup instance
 
-instance Show (SChar c) where
-  showsPrec p s@SChar
-    = showParen (p > appPrec)
-      ( showString "SChar @"
-        . showsPrec appPrec1 (charVal s)
-      )
+instance SSemigroup TL.Symbol where
+  sa %<> sb =
+    let a  = fromSing sa
+        b  = fromSing sb
+    in TL.withSomeSSymbol (T.unpack (a <> b)) unsafeCoerce
 
 -- Convenience functions
 
--- | Given a singleton for @Nat@, call something requiring a
--- @KnownNat@ instance.
-withKnownNat :: Sing n -> (KnownNat n => r) -> r
-withKnownNat SNat f = f
-
--- | Given a singleton for @Symbol@, call something requiring
--- a @KnownSymbol@ instance.
-withKnownSymbol :: Sing n -> (KnownSymbol n => r) -> r
-withKnownSymbol SSym f = f
-
--- | Given a singleton for @Char@, call something requiring
--- a @KnownChar@ instance.
-withKnownChar :: Sing n -> (KnownChar n => r) -> r
-withKnownChar SChar f = f
-
--- | The promotion of 'error'. This version is more poly-kinded for
--- easier use.
-type Error :: k0 -> k
-type family Error (str :: k0) :: k where {}
+-- | A promoted version of 'error'. This implements 'Error' as a stuck type
+-- family with a 'Symbol' argument. Depending on your needs, you might also
+-- consider the following alternatives:
+--
+-- * "Data.Singletons.Base.PolyError" provides @PolyError@, which generalizes
+--   the argument to be kind-polymorphic. This allows passing additional
+--   information to the error besides raw 'Symbol's.
+--
+-- * "Data.Singletons.Base.TypeError" provides @TypeError@, a slightly modified
+--   version of the custom type error machinery found in "GHC.TypeLits". This
+--   allows emitting error messages as compiler errors rather than as stuck type
+--   families.
+type Error :: TL.Symbol -> a
+type family Error (str :: TL.Symbol) :: a where {}
 $(genDefunSymbols [''Error])
-instance SingI (ErrorSym0 :: Symbol ~> a) where
+instance SingI (ErrorSym0 :: TL.Symbol ~> a) where
   sing = singFun1 sError
 
--- | The singleton for 'error'
-sError :: HasCallStack => Sing (str :: Symbol) -> a
+-- | The singleton for 'error'.
+sError :: forall a (str :: TL.Symbol). HasCallStack => Sing str -> Sing (Error @a str)
 sError sstr = error (T.unpack (fromSing sstr))
 
--- | The promotion of 'errorWithoutStackTrace'. This version is more
--- poly-kinded for easier use.
-type ErrorWithoutStackTrace :: k0 -> k
-type family ErrorWithoutStackTrace (str :: k0) :: k where {}
+-- | The promotion of 'errorWithoutStackTrace'.
+type ErrorWithoutStackTrace :: TL.Symbol -> a
+type family ErrorWithoutStackTrace (str :: TL.Symbol) :: a where {}
 $(genDefunSymbols [''ErrorWithoutStackTrace])
-instance SingI (ErrorWithoutStackTraceSym0 :: Symbol ~> a) where
+instance SingI (ErrorWithoutStackTraceSym0 :: TL.Symbol ~> a) where
   sing = singFun1 sErrorWithoutStackTrace
 
 -- | The singleton for 'errorWithoutStackTrace'.
-sErrorWithoutStackTrace :: Sing (str :: Symbol) -> a
+sErrorWithoutStackTrace :: forall a (str :: TL.Symbol). Sing str -> Sing (ErrorWithoutStackTrace @a str)
 sErrorWithoutStackTrace sstr = errorWithoutStackTrace (T.unpack (fromSing sstr))
 
 -- | The promotion of 'undefined'.
-type Undefined :: k
-type family Undefined :: k where {}
+type Undefined :: a
+type family Undefined :: a where {}
 $(genDefunSymbols [''Undefined])
 
 -- | The singleton for 'undefined'.
-sUndefined :: HasCallStack => a
+sUndefined :: forall a. HasCallStack => Sing (Undefined @a)
 sUndefined = undefined
 
 -- | The singleton analogue of '(TN.^)' for 'Natural's.
-(%^) :: Sing a -> Sing b -> Sing (a ^ b)
+(%^) :: Sing a -> Sing b -> Sing (a TN.^ b)
 sa %^ sb =
   let a = fromSing sa
       b = fromSing sb
-      ex = TN.someNatVal (a ^ b)
-  in
-  case ex of
-    SomeNat (_ :: Proxy ab) -> unsafeCoerce (SNat :: Sing ab)
+  in TN.withSomeSNat (a ^ b) unsafeCoerce
 infixr 8 %^
 
 -- Defunctionalization symbols for type-level (^)
-$(genDefunSymbols [''(^)])
+$(genDefunSymbols [''(TN.^)])
 instance SingI (^@#@$) where
   sing = singFun2 (%^)
 instance SingI x => SingI ((^@#@$$) x) where
@@ -296,12 +274,12 @@
 -- with libraries with APIs built around '<=?'.  New code should use
 -- 'CmpNat', exposed through this library through the 'POrd' and 'SOrd'
 -- instances for 'Natural'.
-(%<=?) :: forall (a :: Natural) (b :: Natural). Sing a -> Sing b -> Sing (a <=? b)
+(%<=?) :: forall (a :: Natural) (b :: Natural). Sing a -> Sing b -> Sing (a TN.<=? b)
 sa %<=? sb = unsafeCoerce (sa %<= sb)
 infix 4 %<=?
 
 -- Defunctionalization symbols for (<=?)
-$(genDefunSymbols [''(<=?)])
+$(genDefunSymbols [''(TN.<=?)])
 instance SingI ((<=?@#@$) @Natural) where
   sing = singFun2 (%<=?)
 instance SingI x => SingI ((<=?@#@$$) @Natural x) where
diff --git a/src/Prelude/Singletons.hs b/src/Prelude/Singletons.hs
--- a/src/Prelude/Singletons.hs
+++ b/src/Prelude/Singletons.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE ExplicitNamespaces #-}
 {-# LANGUAGE NoStarIsType #-}
 
 -----------------------------------------------------------------------------
@@ -120,8 +119,8 @@
 
   -- ** Monads and functors
   PFunctor(Fmap, type (<$)), SFunctor(sFmap, (%<$)), type (<$>), (%<$>),
-  PApplicative(Pure, type (<*>), type (*>), type (<*)),
-  SApplicative(sPure, (%<*>), (%*>), (%<*)),
+  PApplicative(Pure, type (<*>), type (*>), type (<*), LiftA2),
+  SApplicative(sPure, (%<*>), (%*>), (%<*), sLiftA2),
   PMonad(type (>>=), type (>>), Return),
   SMonad((%>>=), (%>>), sReturn),
   PMonadFail(Fail), SMonadFail(sFail),
@@ -299,6 +298,7 @@
   type (<*>@#@$), type (<*>@#@$$), type (<*>@#@$$$),
   type (*>@#@$),  type (*>@#@$$),  type (*>@#@$$$),
   type (<*@#@$),  type (<*@#@$$),  type (<*@#@$$$),
+  LiftA2Sym0, LiftA2Sym1, LiftA2Sym2, LiftA2Sym3,
   type (>>=@#@$), type (>>=@#@$$), type (>>=@#@$$$),
   type (>>@#@$),  type (>>@#@$$),  type (>>@#@$$$),
   ReturnSym0, ReturnSym1, FailSym0, FailSym1,
diff --git a/src/Text/Show/Singletons.hs b/src/Text/Show/Singletons.hs
--- a/src/Text/Show/Singletons.hs
+++ b/src/Text/Show/Singletons.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 
@@ -50,8 +50,7 @@
 import           Data.List.Singletons.Internal
 import           Data.Ord (Down)
 import           Data.Ord.Singletons
-import           Data.Proxy
-import           Data.Semigroup.Singletons.Internal
+import           Data.Semigroup.Singletons.Internal.Classes
 import           Data.Singletons
 import           Data.Singletons.Base.Instances
 import           Data.Singletons.TH
@@ -162,10 +161,7 @@
   sShowsPrec _ sn sx =
     let n = fromSing sn
         x = fromSing sx
-        ex = someSymbolVal (P.show n ++ T.unpack x)
-    in
-    case ex of
-      SomeSymbol (_ :: Proxy s) -> unsafeCoerce (SSym :: Sing s)
+    in withSomeSSymbol (P.show n ++ T.unpack x) unsafeCoerce
 
 $(promoteOnly [d|
   showsCharPrec :: Natural -> Char -> SymbolS
@@ -252,18 +248,12 @@
     let p  = fromSing sp
         c  = fromSing sc
         x  = fromSing sx
-        ex = someSymbolVal (P.showsPrec (fromIntegral p) c (T.unpack x))
-    in
-    case ex of
-      SomeSymbol (_ :: Proxy s) -> unsafeCoerce (SSym :: Sing s)
+    in withSomeSSymbol (P.showsPrec (fromIntegral p) c (T.unpack x)) unsafeCoerce
 
   sShowList scs sx =
     let cs = fromSing scs
         x  = fromSing sx
-        ex = someSymbolVal (P.showList cs (T.unpack x))
-    in
-    case ex of
-      SomeSymbol (_ :: Proxy s) -> unsafeCoerce (SSym :: Sing s)
+    in withSomeSSymbol (P.showList cs (T.unpack x)) unsafeCoerce
 
 instance PShow Symbol where
   type ShowsPrec _ s x = ShowSymbol s x
@@ -272,10 +262,7 @@
   sShowsPrec _ ss sx =
     let s  = fromSing ss
         x  = fromSing sx
-        ex = someSymbolVal (P.show s ++ T.unpack x)
-    in
-    case ex of
-      SomeSymbol (_ :: Proxy s) -> unsafeCoerce (SSym :: Sing s)
+    in withSomeSSymbol (P.show s ++ T.unpack x) unsafeCoerce
 
 -- | 'P.show', but with an extra underscore so that its promoted counterpart
 -- ('Show_') will not clash with the 'Show' class.
diff --git a/tests/SingletonsBaseTestSuite.hs b/tests/SingletonsBaseTestSuite.hs
--- a/tests/SingletonsBaseTestSuite.hs
+++ b/tests/SingletonsBaseTestSuite.hs
@@ -58,6 +58,7 @@
       compileAndDumpStdTest "Classes2"
     , compileAndDumpStdTest "FunDeps"
     , compileAndDumpStdTest "T78"
+    , compileAndDumpStdTest "T89"
     , compileAndDumpStdTest "OrdDeriving"
     , compileAndDumpStdTest "BoundedDeriving"
     , compileAndDumpStdTest "BadBoundedDeriving"
@@ -131,6 +132,7 @@
     , compileAndDumpStdTest "T410"
     , compileAndDumpStdTest "T412"
     , compileAndDumpStdTest "T414"
+    , compileAndDumpStdTest "T433"
     , compileAndDumpStdTest "T443"
     , afterSingletonsNat .
       compileAndDumpStdTest "T445"
@@ -144,6 +146,17 @@
     , compileAndDumpStdTest "T492"
     , compileAndDumpStdTest "Natural"
     , compileAndDumpStdTest "T511"
+    , compileAndDumpStdTest "T536"
+    , compileAndDumpStdTest "T555"
+    , compileAndDumpStdTest "T559"
+    , compileAndDumpStdTest "T563"
+    , compileAndDumpStdTest "T565"
+    , compileAndDumpStdTest "T567"
+    , compileAndDumpStdTest "T571"
+    , compileAndDumpStdTest "T581"
+    , compileAndDumpStdTest "T582"
+    , compileAndDumpStdTest "T585"
+    , compileAndDumpStdTest "TypeAbstractions"
     ],
     testCompileAndDumpGroup "Promote"
     [ compileAndDumpStdTest "Constructors"
@@ -154,6 +167,9 @@
     , compileAndDumpStdTest "Prelude"
     , compileAndDumpStdTest "T180"
     , compileAndDumpStdTest "T361"
+    , compileAndDumpStdTest "T601a"
+    , compileAndDumpStdTest "T605"
+    , compileAndDumpStdTest "T613"
     ],
     testGroup "Database client"
     [ compileAndDumpTest "GradingClient/Database" ghcOpts
diff --git a/tests/SingletonsBaseTestSuiteUtils.hs b/tests/SingletonsBaseTestSuiteUtils.hs
--- a/tests/SingletonsBaseTestSuiteUtils.hs
+++ b/tests/SingletonsBaseTestSuiteUtils.hs
@@ -1,5 +1,4 @@
 {-# LANGUAGE DeriveAnyClass #-}
-{-# LANGUAGE DerivingStrategies #-}
 {-# LANGUAGE OverloadedStrings #-}
 
 module SingletonsBaseTestSuiteUtils (
@@ -10,13 +9,12 @@
  , cleanFiles
  ) where
 
-import Build_singletons_base ( ghcPath, ghcFlags, rootDir          )
 import Control.Exception     ( Exception                           )
 import Data.Foldable         ( asum                                )
 import Data.Text             ( Text                                )
 import Data.String           ( IsString(fromString)                )
-import System.FilePath       ( takeBaseName, pathSeparator         )
-import System.FilePath       ( (</>)                               )
+import GHC.Paths             ( ghc                                 )
+import System.FilePath       ( (</>), takeBaseName, pathSeparator  )
 import System.IO             ( IOMode(..), openFile                )
 import System.Process        ( CreateProcess(..), StdStream(..)
                              , createProcess, proc, waitForProcess
@@ -26,6 +24,8 @@
 import qualified Data.Text as Text
 import qualified Turtle
 
+import SingletonsBaseGHCFlags ( ghcFlags, rootDir                  )
+
 -- Some infractructure for handling external process errors
 newtype ProcessException = ProcessException String
   deriving newtype (Eq, Ord, Show)
@@ -46,19 +46,17 @@
   , "-fprint-explicit-kinds"
   , "-O0"
   , "-i" ++ goldenPath
-  , "-XGHC2021"
+  , "-XGHC2024"
   , "-XTemplateHaskell"
-  , "-XDataKinds"
   , "-XTypeFamilies"
-  , "-XGADTs"
   , "-XUndecidableInstances"
   , "-XIncoherentInstances"
-  , "-XLambdaCase"
   , "-XUnboxedTuples"
   , "-XDefaultSignatures"
   , "-XCPP"
   , "-XNoStarIsType"
   , "-XNoNamedWildCards"
+  , "-XTypeAbstractions"
   ]
 
 -- Compile a test using specified GHC options. Save output to file, normalize
@@ -84,7 +82,7 @@
     compileWithGHC :: IO ()
     compileWithGHC = do
       hActualFile <- openFile actualFilePath WriteMode
-      (_, _, _, pid) <- createProcess (proc ghcPath (testPath : opts))
+      (_, _, _, pid) <- createProcess (proc ghc (testPath : opts))
                                               { std_out = UseHandle hActualFile
                                               , std_err = UseHandle hActualFile
                                               , cwd     = Just goldenPath }
diff --git a/tests/compile-and-dump/GradingClient/Database.golden b/tests/compile-and-dump/GradingClient/Database.golden
--- a/tests/compile-and-dump/GradingClient/Database.golden
+++ b/tests/compile-and-dump/GradingClient/Database.golden
@@ -15,3464 +15,3250 @@
       where
         SuccSym0KindInference :: SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>
                                  SuccSym0 a0123456789876543210
-    type instance Apply SuccSym0 a0123456789876543210 = Succ a0123456789876543210
-    instance SuppressUnusedWarnings SuccSym0 where
-      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())
-    type SuccSym1 :: Nat -> Nat
-    type family SuccSym1 (a0123456789876543210 :: Nat) :: Nat where
-      SuccSym1 a0123456789876543210 = Succ a0123456789876543210
-    type TFHelper_0123456789876543210 :: Nat -> Nat -> Bool
-    type family TFHelper_0123456789876543210 (a :: Nat) (a :: Nat) :: Bool where
-      TFHelper_0123456789876543210 Zero Zero = TrueSym0
-      TFHelper_0123456789876543210 Zero (Succ _) = FalseSym0
-      TFHelper_0123456789876543210 (Succ _) Zero = FalseSym0
-      TFHelper_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
-    type TFHelper_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Nat -> (~>) Nat Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Nat -> Nat -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PEq Nat where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type Compare_0123456789876543210 :: Nat -> Nat -> Ordering
-    type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where
-      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
-      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
-      Compare_0123456789876543210 Zero (Succ _) = LTSym0
-      Compare_0123456789876543210 (Succ _) Zero = GTSym0
-    type Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: Nat -> (~>) Nat Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: Nat -> Nat -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance POrd Nat where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
-    data SNat :: Nat -> Type
-      where
-        SZero :: SNat (Zero :: Nat)
-        SSucc :: forall (n :: Nat). (Sing n) -> SNat (Succ n :: Nat)
-    type instance Sing @Nat = SNat
-    instance SingKind Nat where
-      type Demote Nat = Nat
-      fromSing SZero = Zero
-      fromSing (SSucc b) = Succ (fromSing b)
-      toSing Zero = SomeSing SZero
-      toSing (Succ (b :: Demote Nat))
-        = case toSing b :: SomeSing Nat of SomeSing c -> SomeSing (SSucc c)
-    instance SEq Nat => SEq Nat where
-      (%==) ::
-        forall (t1 :: Nat) (t2 :: Nat). Sing t1
-                                        -> Sing t2
-                                           -> Sing (Apply (Apply ((==@#@$) :: TyFun Nat ((~>) Nat Bool)
-                                                                              -> Type) t1) t2)
-      (%==) SZero SZero = STrue
-      (%==) SZero (SSucc _) = SFalse
-      (%==) (SSucc _) SZero = SFalse
-      (%==)
-        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-            sB_0123456789876543210
-    instance SOrd Nat => SOrd Nat where
-      sCompare ::
-        forall (t1 :: Nat) (t2 :: Nat). Sing t1
-                                        -> Sing t2
-                                           -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering)
-                                                                                 -> Type) t1) t2)
-      sCompare SZero SZero
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            SNil
-      sCompare
-        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               SNil)
-      sCompare SZero (SSucc _) = SLT
-      sCompare (SSucc _) SZero = SGT
-    instance SDecide Nat => SDecide Nat where
-      (%~) SZero SZero = Proved Refl
-      (%~) SZero (SSucc _) = Disproved (\ x -> case x of {})
-      (%~) (SSucc _) SZero = Disproved (\ x -> case x of {})
-      (%~) (SSucc a) (SSucc b)
-        = case ((%~) a) b of
-            Proved Refl -> Proved Refl
-            Disproved contra
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-    instance SDecide Nat =>
-             Data.Type.Equality.TestEquality (SNat :: Nat -> Type) where
-      Data.Type.Equality.testEquality
-        = Data.Singletons.Decide.decideEquality
-    instance SDecide Nat =>
-             Data.Type.Coercion.TestCoercion (SNat :: Nat -> Type) where
-      Data.Type.Coercion.testCoercion
-        = Data.Singletons.Decide.decideCoercion
-    instance SingI Zero where
-      sing = SZero
-    instance SingI n => SingI (Succ (n :: Nat)) where
-      sing = SSucc sing
-    instance SingI1 Succ where
-      liftSing = SSucc
-    instance SingI (SuccSym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @SuccSym0) SSucc
-GradingClient/Database.hs:(0,0)-(0,0): Splicing declarations
-    singletons
-      [d| append :: Schema -> Schema -> Schema
-          append (Sch s1) (Sch s2) = Sch (s1 ++ s2)
-          attrNotIn :: Attribute -> Schema -> Bool
-          attrNotIn _ (Sch []) = True
-          attrNotIn (Attr name u) (Sch ((Attr name' _) : t))
-            = (name /= name') && (attrNotIn (Attr name u) (Sch t))
-          disjoint :: Schema -> Schema -> Bool
-          disjoint (Sch []) _ = True
-          disjoint (Sch (h : t)) s = (attrNotIn h s) && (disjoint (Sch t) s)
-          occurs :: [AChar] -> Schema -> Bool
-          occurs _ (Sch []) = False
-          occurs name (Sch ((Attr name' _) : attrs))
-            = name == name' || occurs name (Sch attrs)
-          lookup :: [AChar] -> Schema -> U
-          lookup _ (Sch []) = undefined
-          lookup name (Sch ((Attr name' u) : attrs))
-            = if name == name' then u else lookup name (Sch attrs)
-          
-          data U
-            = BOOL | STRING | NAT | VEC U Nat
-            deriving (Read, Eq, Show)
-          data AChar
-            = CA |
-              CB |
-              CC |
-              CD |
-              CE |
-              CF |
-              CG |
-              CH |
-              CI |
-              CJ |
-              CK |
-              CL |
-              CM |
-              CN |
-              CO |
-              CP |
-              CQ |
-              CR |
-              CS |
-              CT |
-              CU |
-              CV |
-              CW |
-              CX |
-              CY |
-              CZ
-            deriving (Read, Show, Eq)
-          data Attribute = Attr [AChar] U
-          data Schema = Sch [Attribute] |]
-  ======>
-    data U
-      = BOOL | STRING | NAT | VEC U Nat
-      deriving (Read, Eq, Show)
-    data AChar
-      = CA |
-        CB |
-        CC |
-        CD |
-        CE |
-        CF |
-        CG |
-        CH |
-        CI |
-        CJ |
-        CK |
-        CL |
-        CM |
-        CN |
-        CO |
-        CP |
-        CQ |
-        CR |
-        CS |
-        CT |
-        CU |
-        CV |
-        CW |
-        CX |
-        CY |
-        CZ
-      deriving (Read, Show, Eq)
-    data Attribute = Attr [AChar] U
-    data Schema = Sch [Attribute]
-    append :: Schema -> Schema -> Schema
-    append (Sch s1) (Sch s2) = Sch (s1 ++ s2)
-    attrNotIn :: Attribute -> Schema -> Bool
-    attrNotIn _ (Sch []) = True
-    attrNotIn (Attr name u) (Sch (Attr name' _ : t))
-      = ((name /= name') && (attrNotIn ((Attr name) u)) (Sch t))
-    disjoint :: Schema -> Schema -> Bool
-    disjoint (Sch []) _ = True
-    disjoint (Sch (h : t)) s
-      = ((attrNotIn h) s && (disjoint (Sch t)) s)
-    occurs :: [AChar] -> Schema -> Bool
-    occurs _ (Sch []) = False
-    occurs name (Sch (Attr name' _ : attrs))
-      = ((name == name') || (occurs name) (Sch attrs))
-    lookup :: [AChar] -> Schema -> U
-    lookup _ (Sch []) = undefined
-    lookup name (Sch (Attr name' u : attrs))
-      = if (name == name') then u else (lookup name) (Sch attrs)
-    type BOOLSym0 :: U
-    type family BOOLSym0 :: U where
-      BOOLSym0 = BOOL
-    type STRINGSym0 :: U
-    type family STRINGSym0 :: U where
-      STRINGSym0 = STRING
-    type NATSym0 :: U
-    type family NATSym0 :: U where
-      NATSym0 = NAT
-    type VECSym0 :: (~>) U ((~>) Nat U)
-    data VECSym0 :: (~>) U ((~>) Nat U)
-      where
-        VECSym0KindInference :: SameKind (Apply VECSym0 arg) (VECSym1 arg) =>
-                                VECSym0 a0123456789876543210
-    type instance Apply VECSym0 a0123456789876543210 = VECSym1 a0123456789876543210
-    instance SuppressUnusedWarnings VECSym0 where
-      suppressUnusedWarnings = snd (((,) VECSym0KindInference) ())
-    type VECSym1 :: U -> (~>) Nat U
-    data VECSym1 (a0123456789876543210 :: U) :: (~>) Nat U
-      where
-        VECSym1KindInference :: SameKind (Apply (VECSym1 a0123456789876543210) arg) (VECSym2 a0123456789876543210 arg) =>
-                                VECSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (VECSym1 a0123456789876543210) a0123456789876543210 = VEC a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (VECSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) VECSym1KindInference) ())
-    type VECSym2 :: U -> Nat -> U
-    type family VECSym2 (a0123456789876543210 :: U) (a0123456789876543210 :: Nat) :: U where
-      VECSym2 a0123456789876543210 a0123456789876543210 = VEC a0123456789876543210 a0123456789876543210
-    type CASym0 :: AChar
-    type family CASym0 :: AChar where
-      CASym0 = CA
-    type CBSym0 :: AChar
-    type family CBSym0 :: AChar where
-      CBSym0 = CB
-    type CCSym0 :: AChar
-    type family CCSym0 :: AChar where
-      CCSym0 = CC
-    type CDSym0 :: AChar
-    type family CDSym0 :: AChar where
-      CDSym0 = CD
-    type CESym0 :: AChar
-    type family CESym0 :: AChar where
-      CESym0 = CE
-    type CFSym0 :: AChar
-    type family CFSym0 :: AChar where
-      CFSym0 = CF
-    type CGSym0 :: AChar
-    type family CGSym0 :: AChar where
-      CGSym0 = CG
-    type CHSym0 :: AChar
-    type family CHSym0 :: AChar where
-      CHSym0 = CH
-    type CISym0 :: AChar
-    type family CISym0 :: AChar where
-      CISym0 = CI
-    type CJSym0 :: AChar
-    type family CJSym0 :: AChar where
-      CJSym0 = CJ
-    type CKSym0 :: AChar
-    type family CKSym0 :: AChar where
-      CKSym0 = CK
-    type CLSym0 :: AChar
-    type family CLSym0 :: AChar where
-      CLSym0 = CL
-    type CMSym0 :: AChar
-    type family CMSym0 :: AChar where
-      CMSym0 = CM
-    type CNSym0 :: AChar
-    type family CNSym0 :: AChar where
-      CNSym0 = CN
-    type COSym0 :: AChar
-    type family COSym0 :: AChar where
-      COSym0 = CO
-    type CPSym0 :: AChar
-    type family CPSym0 :: AChar where
-      CPSym0 = CP
-    type CQSym0 :: AChar
-    type family CQSym0 :: AChar where
-      CQSym0 = CQ
-    type CRSym0 :: AChar
-    type family CRSym0 :: AChar where
-      CRSym0 = CR
-    type CSSym0 :: AChar
-    type family CSSym0 :: AChar where
-      CSSym0 = CS
-    type CTSym0 :: AChar
-    type family CTSym0 :: AChar where
-      CTSym0 = CT
-    type CUSym0 :: AChar
-    type family CUSym0 :: AChar where
-      CUSym0 = CU
-    type CVSym0 :: AChar
-    type family CVSym0 :: AChar where
-      CVSym0 = CV
-    type CWSym0 :: AChar
-    type family CWSym0 :: AChar where
-      CWSym0 = CW
-    type CXSym0 :: AChar
-    type family CXSym0 :: AChar where
-      CXSym0 = CX
-    type CYSym0 :: AChar
-    type family CYSym0 :: AChar where
-      CYSym0 = CY
-    type CZSym0 :: AChar
-    type family CZSym0 :: AChar where
-      CZSym0 = CZ
-    type AttrSym0 :: (~>) [AChar] ((~>) U Attribute)
-    data AttrSym0 :: (~>) [AChar] ((~>) U Attribute)
-      where
-        AttrSym0KindInference :: SameKind (Apply AttrSym0 arg) (AttrSym1 arg) =>
-                                 AttrSym0 a0123456789876543210
-    type instance Apply AttrSym0 a0123456789876543210 = AttrSym1 a0123456789876543210
-    instance SuppressUnusedWarnings AttrSym0 where
-      suppressUnusedWarnings = snd (((,) AttrSym0KindInference) ())
-    type AttrSym1 :: [AChar] -> (~>) U Attribute
-    data AttrSym1 (a0123456789876543210 :: [AChar]) :: (~>) U Attribute
-      where
-        AttrSym1KindInference :: SameKind (Apply (AttrSym1 a0123456789876543210) arg) (AttrSym2 a0123456789876543210 arg) =>
-                                 AttrSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (AttrSym1 a0123456789876543210) a0123456789876543210 = Attr a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (AttrSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) AttrSym1KindInference) ())
-    type AttrSym2 :: [AChar] -> U -> Attribute
-    type family AttrSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: U) :: Attribute where
-      AttrSym2 a0123456789876543210 a0123456789876543210 = Attr a0123456789876543210 a0123456789876543210
-    type SchSym0 :: (~>) [Attribute] Schema
-    data SchSym0 :: (~>) [Attribute] Schema
-      where
-        SchSym0KindInference :: SameKind (Apply SchSym0 arg) (SchSym1 arg) =>
-                                SchSym0 a0123456789876543210
-    type instance Apply SchSym0 a0123456789876543210 = Sch a0123456789876543210
-    instance SuppressUnusedWarnings SchSym0 where
-      suppressUnusedWarnings = snd (((,) SchSym0KindInference) ())
-    type SchSym1 :: [Attribute] -> Schema
-    type family SchSym1 (a0123456789876543210 :: [Attribute]) :: Schema where
-      SchSym1 a0123456789876543210 = Sch a0123456789876543210
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210
-      where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210
-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)
-               ())
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210 name'0123456789876543210
-      where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210 name'0123456789876543210
-    type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210) name'0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210) where
-      suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference)
-               ())
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210 u0123456789876543210
-      where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210 u0123456789876543210
-    type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210) u0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210) where
-      suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference)
-               ())
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210
-      where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym3KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name0123456789876543210 name'0123456789876543210 u0123456789876543210 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210
-    type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210) attrs0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210) where
-      suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym3KindInference)
-               ())
-    type family Let0123456789876543210Scrutinee_0123456789876543210Sym4 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 where
-      Let0123456789876543210Scrutinee_0123456789876543210Sym4 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210
-    type family Let0123456789876543210Scrutinee_0123456789876543210 name name' u attrs where
-      Let0123456789876543210Scrutinee_0123456789876543210 name name' u attrs = Apply (Apply (==@#@$) name) name'
-    type family Case_0123456789876543210 name name' u attrs t where
-      Case_0123456789876543210 name name' u attrs 'True = u
-      Case_0123456789876543210 name name' u attrs 'False = Apply (Apply LookupSym0 name) (Apply SchSym0 attrs)
-    type LookupSym0 :: (~>) [AChar] ((~>) Schema U)
-    data LookupSym0 :: (~>) [AChar] ((~>) Schema U)
-      where
-        LookupSym0KindInference :: SameKind (Apply LookupSym0 arg) (LookupSym1 arg) =>
-                                   LookupSym0 a0123456789876543210
-    type instance Apply LookupSym0 a0123456789876543210 = LookupSym1 a0123456789876543210
-    instance SuppressUnusedWarnings LookupSym0 where
-      suppressUnusedWarnings = snd (((,) LookupSym0KindInference) ())
-    type LookupSym1 :: [AChar] -> (~>) Schema U
-    data LookupSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema U
-      where
-        LookupSym1KindInference :: SameKind (Apply (LookupSym1 a0123456789876543210) arg) (LookupSym2 a0123456789876543210 arg) =>
-                                   LookupSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (LookupSym1 a0123456789876543210) a0123456789876543210 = Lookup a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (LookupSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) LookupSym1KindInference) ())
-    type LookupSym2 :: [AChar] -> Schema -> U
-    type family LookupSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) :: U where
-      LookupSym2 a0123456789876543210 a0123456789876543210 = Lookup a0123456789876543210 a0123456789876543210
-    type OccursSym0 :: (~>) [AChar] ((~>) Schema Bool)
-    data OccursSym0 :: (~>) [AChar] ((~>) Schema Bool)
-      where
-        OccursSym0KindInference :: SameKind (Apply OccursSym0 arg) (OccursSym1 arg) =>
-                                   OccursSym0 a0123456789876543210
-    type instance Apply OccursSym0 a0123456789876543210 = OccursSym1 a0123456789876543210
-    instance SuppressUnusedWarnings OccursSym0 where
-      suppressUnusedWarnings = snd (((,) OccursSym0KindInference) ())
-    type OccursSym1 :: [AChar] -> (~>) Schema Bool
-    data OccursSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema Bool
-      where
-        OccursSym1KindInference :: SameKind (Apply (OccursSym1 a0123456789876543210) arg) (OccursSym2 a0123456789876543210 arg) =>
-                                   OccursSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (OccursSym1 a0123456789876543210) a0123456789876543210 = Occurs a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (OccursSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) OccursSym1KindInference) ())
-    type OccursSym2 :: [AChar] -> Schema -> Bool
-    type family OccursSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) :: Bool where
-      OccursSym2 a0123456789876543210 a0123456789876543210 = Occurs a0123456789876543210 a0123456789876543210
-    type DisjointSym0 :: (~>) Schema ((~>) Schema Bool)
-    data DisjointSym0 :: (~>) Schema ((~>) Schema Bool)
-      where
-        DisjointSym0KindInference :: SameKind (Apply DisjointSym0 arg) (DisjointSym1 arg) =>
-                                     DisjointSym0 a0123456789876543210
-    type instance Apply DisjointSym0 a0123456789876543210 = DisjointSym1 a0123456789876543210
-    instance SuppressUnusedWarnings DisjointSym0 where
-      suppressUnusedWarnings = snd (((,) DisjointSym0KindInference) ())
-    type DisjointSym1 :: Schema -> (~>) Schema Bool
-    data DisjointSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Bool
-      where
-        DisjointSym1KindInference :: SameKind (Apply (DisjointSym1 a0123456789876543210) arg) (DisjointSym2 a0123456789876543210 arg) =>
-                                     DisjointSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (DisjointSym1 a0123456789876543210) a0123456789876543210 = Disjoint a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (DisjointSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) DisjointSym1KindInference) ())
-    type DisjointSym2 :: Schema -> Schema -> Bool
-    type family DisjointSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) :: Bool where
-      DisjointSym2 a0123456789876543210 a0123456789876543210 = Disjoint a0123456789876543210 a0123456789876543210
-    type AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool)
-    data AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool)
-      where
-        AttrNotInSym0KindInference :: SameKind (Apply AttrNotInSym0 arg) (AttrNotInSym1 arg) =>
-                                      AttrNotInSym0 a0123456789876543210
-    type instance Apply AttrNotInSym0 a0123456789876543210 = AttrNotInSym1 a0123456789876543210
-    instance SuppressUnusedWarnings AttrNotInSym0 where
-      suppressUnusedWarnings = snd (((,) AttrNotInSym0KindInference) ())
-    type AttrNotInSym1 :: Attribute -> (~>) Schema Bool
-    data AttrNotInSym1 (a0123456789876543210 :: Attribute) :: (~>) Schema Bool
-      where
-        AttrNotInSym1KindInference :: SameKind (Apply (AttrNotInSym1 a0123456789876543210) arg) (AttrNotInSym2 a0123456789876543210 arg) =>
-                                      AttrNotInSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (AttrNotInSym1 a0123456789876543210) a0123456789876543210 = AttrNotIn a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (AttrNotInSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) AttrNotInSym1KindInference) ())
-    type AttrNotInSym2 :: Attribute -> Schema -> Bool
-    type family AttrNotInSym2 (a0123456789876543210 :: Attribute) (a0123456789876543210 :: Schema) :: Bool where
-      AttrNotInSym2 a0123456789876543210 a0123456789876543210 = AttrNotIn a0123456789876543210 a0123456789876543210
-    type AppendSym0 :: (~>) Schema ((~>) Schema Schema)
-    data AppendSym0 :: (~>) Schema ((~>) Schema Schema)
-      where
-        AppendSym0KindInference :: SameKind (Apply AppendSym0 arg) (AppendSym1 arg) =>
-                                   AppendSym0 a0123456789876543210
-    type instance Apply AppendSym0 a0123456789876543210 = AppendSym1 a0123456789876543210
-    instance SuppressUnusedWarnings AppendSym0 where
-      suppressUnusedWarnings = snd (((,) AppendSym0KindInference) ())
-    type AppendSym1 :: Schema -> (~>) Schema Schema
-    data AppendSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Schema
-      where
-        AppendSym1KindInference :: SameKind (Apply (AppendSym1 a0123456789876543210) arg) (AppendSym2 a0123456789876543210 arg) =>
-                                   AppendSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (AppendSym1 a0123456789876543210) a0123456789876543210 = Append a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (AppendSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) AppendSym1KindInference) ())
-    type AppendSym2 :: Schema -> Schema -> Schema
-    type family AppendSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) :: Schema where
-      AppendSym2 a0123456789876543210 a0123456789876543210 = Append a0123456789876543210 a0123456789876543210
-    type Lookup :: [AChar] -> Schema -> U
-    type family Lookup (a :: [AChar]) (a :: Schema) :: U where
-      Lookup _ (Sch '[]) = UndefinedSym0
-      Lookup name (Sch ('(:) (Attr name' u) attrs)) = Case_0123456789876543210 name name' u attrs (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs)
-    type Occurs :: [AChar] -> Schema -> Bool
-    type family Occurs (a :: [AChar]) (a :: Schema) :: Bool where
-      Occurs _ (Sch '[]) = FalseSym0
-      Occurs name (Sch ('(:) (Attr name' _) attrs)) = Apply (Apply (||@#@$) (Apply (Apply (==@#@$) name) name')) (Apply (Apply OccursSym0 name) (Apply SchSym0 attrs))
-    type Disjoint :: Schema -> Schema -> Bool
-    type family Disjoint (a :: Schema) (a :: Schema) :: Bool where
-      Disjoint (Sch '[]) _ = TrueSym0
-      Disjoint (Sch ('(:) h t)) s = Apply (Apply (&&@#@$) (Apply (Apply AttrNotInSym0 h) s)) (Apply (Apply DisjointSym0 (Apply SchSym0 t)) s)
-    type AttrNotIn :: Attribute -> Schema -> Bool
-    type family AttrNotIn (a :: Attribute) (a :: Schema) :: Bool where
-      AttrNotIn _ (Sch '[]) = TrueSym0
-      AttrNotIn (Attr name u) (Sch ('(:) (Attr name' _) t)) = Apply (Apply (&&@#@$) (Apply (Apply (/=@#@$) name) name')) (Apply (Apply AttrNotInSym0 (Apply (Apply AttrSym0 name) u)) (Apply SchSym0 t))
-    type Append :: Schema -> Schema -> Schema
-    type family Append (a :: Schema) (a :: Schema) :: Schema where
-      Append (Sch s1) (Sch s2) = Apply SchSym0 (Apply (Apply (++@#@$) s1) s2)
-    type TFHelper_0123456789876543210 :: U -> U -> Bool
-    type family TFHelper_0123456789876543210 (a :: U) (a :: U) :: Bool where
-      TFHelper_0123456789876543210 BOOL BOOL = TrueSym0
-      TFHelper_0123456789876543210 BOOL STRING = FalseSym0
-      TFHelper_0123456789876543210 BOOL NAT = FalseSym0
-      TFHelper_0123456789876543210 BOOL (VEC _ _) = FalseSym0
-      TFHelper_0123456789876543210 STRING BOOL = FalseSym0
-      TFHelper_0123456789876543210 STRING STRING = TrueSym0
-      TFHelper_0123456789876543210 STRING NAT = FalseSym0
-      TFHelper_0123456789876543210 STRING (VEC _ _) = FalseSym0
-      TFHelper_0123456789876543210 NAT BOOL = FalseSym0
-      TFHelper_0123456789876543210 NAT STRING = FalseSym0
-      TFHelper_0123456789876543210 NAT NAT = TrueSym0
-      TFHelper_0123456789876543210 NAT (VEC _ _) = FalseSym0
-      TFHelper_0123456789876543210 (VEC _ _) BOOL = FalseSym0
-      TFHelper_0123456789876543210 (VEC _ _) STRING = FalseSym0
-      TFHelper_0123456789876543210 (VEC _ _) NAT = FalseSym0
-      TFHelper_0123456789876543210 (VEC a_0123456789876543210 a_0123456789876543210) (VEC b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)
-    type TFHelper_0123456789876543210Sym0 :: (~>) U ((~>) U Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) U ((~>) U Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: U -> (~>) U Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: U) :: (~>) U Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: U -> U -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: U) (a0123456789876543210 :: U) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PEq U where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> U -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: U) (a :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210 _ BOOL a_0123456789876543210 = Apply (Apply ShowStringSym0 "BOOL") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ STRING a_0123456789876543210 = Apply (Apply ShowStringSym0 "STRING") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ NAT a_0123456789876543210 = Apply (Apply ShowStringSym0 "NAT") a_0123456789876543210
-      ShowsPrec_0123456789876543210 p_0123456789876543210 (VEC arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "VEC ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) U ((~>) Symbol Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) U ((~>) Symbol Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) U ((~>) Symbol Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) U ((~>) Symbol Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> U -> (~>) Symbol Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: U) :: (~>) Symbol Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> U -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: U) (a0123456789876543210 :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PShow U where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> AChar -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: AChar) (a :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210 _ CA a_0123456789876543210 = Apply (Apply ShowStringSym0 "CA") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CB a_0123456789876543210 = Apply (Apply ShowStringSym0 "CB") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CC a_0123456789876543210 = Apply (Apply ShowStringSym0 "CC") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CD a_0123456789876543210 = Apply (Apply ShowStringSym0 "CD") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CE a_0123456789876543210 = Apply (Apply ShowStringSym0 "CE") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CF a_0123456789876543210 = Apply (Apply ShowStringSym0 "CF") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CG a_0123456789876543210 = Apply (Apply ShowStringSym0 "CG") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CH a_0123456789876543210 = Apply (Apply ShowStringSym0 "CH") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CI a_0123456789876543210 = Apply (Apply ShowStringSym0 "CI") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CJ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CJ") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CK a_0123456789876543210 = Apply (Apply ShowStringSym0 "CK") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CL a_0123456789876543210 = Apply (Apply ShowStringSym0 "CL") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CM a_0123456789876543210 = Apply (Apply ShowStringSym0 "CM") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CN a_0123456789876543210 = Apply (Apply ShowStringSym0 "CN") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CO a_0123456789876543210 = Apply (Apply ShowStringSym0 "CO") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CP a_0123456789876543210 = Apply (Apply ShowStringSym0 "CP") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CQ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CQ") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CR a_0123456789876543210 = Apply (Apply ShowStringSym0 "CR") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CS a_0123456789876543210 = Apply (Apply ShowStringSym0 "CS") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CT a_0123456789876543210 = Apply (Apply ShowStringSym0 "CT") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CU a_0123456789876543210 = Apply (Apply ShowStringSym0 "CU") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CV a_0123456789876543210 = Apply (Apply ShowStringSym0 "CV") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CW a_0123456789876543210 = Apply (Apply ShowStringSym0 "CW") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CX a_0123456789876543210 = Apply (Apply ShowStringSym0 "CX") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CY a_0123456789876543210 = Apply (Apply ShowStringSym0 "CY") a_0123456789876543210
-      ShowsPrec_0123456789876543210 _ CZ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CZ") a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) AChar ((~>) Symbol Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) AChar ((~>) Symbol Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) AChar ((~>) Symbol Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) AChar ((~>) Symbol Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> AChar -> (~>) Symbol Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: AChar) :: (~>) Symbol Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> AChar -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: AChar) (a0123456789876543210 :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PShow AChar where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
-    type TFHelper_0123456789876543210 :: AChar -> AChar -> Bool
-    type family TFHelper_0123456789876543210 (a :: AChar) (a :: AChar) :: Bool where
-      TFHelper_0123456789876543210 CA CA = TrueSym0
-      TFHelper_0123456789876543210 CA CB = FalseSym0
-      TFHelper_0123456789876543210 CA CC = FalseSym0
-      TFHelper_0123456789876543210 CA CD = FalseSym0
-      TFHelper_0123456789876543210 CA CE = FalseSym0
-      TFHelper_0123456789876543210 CA CF = FalseSym0
-      TFHelper_0123456789876543210 CA CG = FalseSym0
-      TFHelper_0123456789876543210 CA CH = FalseSym0
-      TFHelper_0123456789876543210 CA CI = FalseSym0
-      TFHelper_0123456789876543210 CA CJ = FalseSym0
-      TFHelper_0123456789876543210 CA CK = FalseSym0
-      TFHelper_0123456789876543210 CA CL = FalseSym0
-      TFHelper_0123456789876543210 CA CM = FalseSym0
-      TFHelper_0123456789876543210 CA CN = FalseSym0
-      TFHelper_0123456789876543210 CA CO = FalseSym0
-      TFHelper_0123456789876543210 CA CP = FalseSym0
-      TFHelper_0123456789876543210 CA CQ = FalseSym0
-      TFHelper_0123456789876543210 CA CR = FalseSym0
-      TFHelper_0123456789876543210 CA CS = FalseSym0
-      TFHelper_0123456789876543210 CA CT = FalseSym0
-      TFHelper_0123456789876543210 CA CU = FalseSym0
-      TFHelper_0123456789876543210 CA CV = FalseSym0
-      TFHelper_0123456789876543210 CA CW = FalseSym0
-      TFHelper_0123456789876543210 CA CX = FalseSym0
-      TFHelper_0123456789876543210 CA CY = FalseSym0
-      TFHelper_0123456789876543210 CA CZ = FalseSym0
-      TFHelper_0123456789876543210 CB CA = FalseSym0
-      TFHelper_0123456789876543210 CB CB = TrueSym0
-      TFHelper_0123456789876543210 CB CC = FalseSym0
-      TFHelper_0123456789876543210 CB CD = FalseSym0
-      TFHelper_0123456789876543210 CB CE = FalseSym0
-      TFHelper_0123456789876543210 CB CF = FalseSym0
-      TFHelper_0123456789876543210 CB CG = FalseSym0
-      TFHelper_0123456789876543210 CB CH = FalseSym0
-      TFHelper_0123456789876543210 CB CI = FalseSym0
-      TFHelper_0123456789876543210 CB CJ = FalseSym0
-      TFHelper_0123456789876543210 CB CK = FalseSym0
-      TFHelper_0123456789876543210 CB CL = FalseSym0
-      TFHelper_0123456789876543210 CB CM = FalseSym0
-      TFHelper_0123456789876543210 CB CN = FalseSym0
-      TFHelper_0123456789876543210 CB CO = FalseSym0
-      TFHelper_0123456789876543210 CB CP = FalseSym0
-      TFHelper_0123456789876543210 CB CQ = FalseSym0
-      TFHelper_0123456789876543210 CB CR = FalseSym0
-      TFHelper_0123456789876543210 CB CS = FalseSym0
-      TFHelper_0123456789876543210 CB CT = FalseSym0
-      TFHelper_0123456789876543210 CB CU = FalseSym0
-      TFHelper_0123456789876543210 CB CV = FalseSym0
-      TFHelper_0123456789876543210 CB CW = FalseSym0
-      TFHelper_0123456789876543210 CB CX = FalseSym0
-      TFHelper_0123456789876543210 CB CY = FalseSym0
-      TFHelper_0123456789876543210 CB CZ = FalseSym0
-      TFHelper_0123456789876543210 CC CA = FalseSym0
-      TFHelper_0123456789876543210 CC CB = FalseSym0
-      TFHelper_0123456789876543210 CC CC = TrueSym0
-      TFHelper_0123456789876543210 CC CD = FalseSym0
-      TFHelper_0123456789876543210 CC CE = FalseSym0
-      TFHelper_0123456789876543210 CC CF = FalseSym0
-      TFHelper_0123456789876543210 CC CG = FalseSym0
-      TFHelper_0123456789876543210 CC CH = FalseSym0
-      TFHelper_0123456789876543210 CC CI = FalseSym0
-      TFHelper_0123456789876543210 CC CJ = FalseSym0
-      TFHelper_0123456789876543210 CC CK = FalseSym0
-      TFHelper_0123456789876543210 CC CL = FalseSym0
-      TFHelper_0123456789876543210 CC CM = FalseSym0
-      TFHelper_0123456789876543210 CC CN = FalseSym0
-      TFHelper_0123456789876543210 CC CO = FalseSym0
-      TFHelper_0123456789876543210 CC CP = FalseSym0
-      TFHelper_0123456789876543210 CC CQ = FalseSym0
-      TFHelper_0123456789876543210 CC CR = FalseSym0
-      TFHelper_0123456789876543210 CC CS = FalseSym0
-      TFHelper_0123456789876543210 CC CT = FalseSym0
-      TFHelper_0123456789876543210 CC CU = FalseSym0
-      TFHelper_0123456789876543210 CC CV = FalseSym0
-      TFHelper_0123456789876543210 CC CW = FalseSym0
-      TFHelper_0123456789876543210 CC CX = FalseSym0
-      TFHelper_0123456789876543210 CC CY = FalseSym0
-      TFHelper_0123456789876543210 CC CZ = FalseSym0
-      TFHelper_0123456789876543210 CD CA = FalseSym0
-      TFHelper_0123456789876543210 CD CB = FalseSym0
-      TFHelper_0123456789876543210 CD CC = FalseSym0
-      TFHelper_0123456789876543210 CD CD = TrueSym0
-      TFHelper_0123456789876543210 CD CE = FalseSym0
-      TFHelper_0123456789876543210 CD CF = FalseSym0
-      TFHelper_0123456789876543210 CD CG = FalseSym0
-      TFHelper_0123456789876543210 CD CH = FalseSym0
-      TFHelper_0123456789876543210 CD CI = FalseSym0
-      TFHelper_0123456789876543210 CD CJ = FalseSym0
-      TFHelper_0123456789876543210 CD CK = FalseSym0
-      TFHelper_0123456789876543210 CD CL = FalseSym0
-      TFHelper_0123456789876543210 CD CM = FalseSym0
-      TFHelper_0123456789876543210 CD CN = FalseSym0
-      TFHelper_0123456789876543210 CD CO = FalseSym0
-      TFHelper_0123456789876543210 CD CP = FalseSym0
-      TFHelper_0123456789876543210 CD CQ = FalseSym0
-      TFHelper_0123456789876543210 CD CR = FalseSym0
-      TFHelper_0123456789876543210 CD CS = FalseSym0
-      TFHelper_0123456789876543210 CD CT = FalseSym0
-      TFHelper_0123456789876543210 CD CU = FalseSym0
-      TFHelper_0123456789876543210 CD CV = FalseSym0
-      TFHelper_0123456789876543210 CD CW = FalseSym0
-      TFHelper_0123456789876543210 CD CX = FalseSym0
-      TFHelper_0123456789876543210 CD CY = FalseSym0
-      TFHelper_0123456789876543210 CD CZ = FalseSym0
-      TFHelper_0123456789876543210 CE CA = FalseSym0
-      TFHelper_0123456789876543210 CE CB = FalseSym0
-      TFHelper_0123456789876543210 CE CC = FalseSym0
-      TFHelper_0123456789876543210 CE CD = FalseSym0
-      TFHelper_0123456789876543210 CE CE = TrueSym0
-      TFHelper_0123456789876543210 CE CF = FalseSym0
-      TFHelper_0123456789876543210 CE CG = FalseSym0
-      TFHelper_0123456789876543210 CE CH = FalseSym0
-      TFHelper_0123456789876543210 CE CI = FalseSym0
-      TFHelper_0123456789876543210 CE CJ = FalseSym0
-      TFHelper_0123456789876543210 CE CK = FalseSym0
-      TFHelper_0123456789876543210 CE CL = FalseSym0
-      TFHelper_0123456789876543210 CE CM = FalseSym0
-      TFHelper_0123456789876543210 CE CN = FalseSym0
-      TFHelper_0123456789876543210 CE CO = FalseSym0
-      TFHelper_0123456789876543210 CE CP = FalseSym0
-      TFHelper_0123456789876543210 CE CQ = FalseSym0
-      TFHelper_0123456789876543210 CE CR = FalseSym0
-      TFHelper_0123456789876543210 CE CS = FalseSym0
-      TFHelper_0123456789876543210 CE CT = FalseSym0
-      TFHelper_0123456789876543210 CE CU = FalseSym0
-      TFHelper_0123456789876543210 CE CV = FalseSym0
-      TFHelper_0123456789876543210 CE CW = FalseSym0
-      TFHelper_0123456789876543210 CE CX = FalseSym0
-      TFHelper_0123456789876543210 CE CY = FalseSym0
-      TFHelper_0123456789876543210 CE CZ = FalseSym0
-      TFHelper_0123456789876543210 CF CA = FalseSym0
-      TFHelper_0123456789876543210 CF CB = FalseSym0
-      TFHelper_0123456789876543210 CF CC = FalseSym0
-      TFHelper_0123456789876543210 CF CD = FalseSym0
-      TFHelper_0123456789876543210 CF CE = FalseSym0
-      TFHelper_0123456789876543210 CF CF = TrueSym0
-      TFHelper_0123456789876543210 CF CG = FalseSym0
-      TFHelper_0123456789876543210 CF CH = FalseSym0
-      TFHelper_0123456789876543210 CF CI = FalseSym0
-      TFHelper_0123456789876543210 CF CJ = FalseSym0
-      TFHelper_0123456789876543210 CF CK = FalseSym0
-      TFHelper_0123456789876543210 CF CL = FalseSym0
-      TFHelper_0123456789876543210 CF CM = FalseSym0
-      TFHelper_0123456789876543210 CF CN = FalseSym0
-      TFHelper_0123456789876543210 CF CO = FalseSym0
-      TFHelper_0123456789876543210 CF CP = FalseSym0
-      TFHelper_0123456789876543210 CF CQ = FalseSym0
-      TFHelper_0123456789876543210 CF CR = FalseSym0
-      TFHelper_0123456789876543210 CF CS = FalseSym0
-      TFHelper_0123456789876543210 CF CT = FalseSym0
-      TFHelper_0123456789876543210 CF CU = FalseSym0
-      TFHelper_0123456789876543210 CF CV = FalseSym0
-      TFHelper_0123456789876543210 CF CW = FalseSym0
-      TFHelper_0123456789876543210 CF CX = FalseSym0
-      TFHelper_0123456789876543210 CF CY = FalseSym0
-      TFHelper_0123456789876543210 CF CZ = FalseSym0
-      TFHelper_0123456789876543210 CG CA = FalseSym0
-      TFHelper_0123456789876543210 CG CB = FalseSym0
-      TFHelper_0123456789876543210 CG CC = FalseSym0
-      TFHelper_0123456789876543210 CG CD = FalseSym0
-      TFHelper_0123456789876543210 CG CE = FalseSym0
-      TFHelper_0123456789876543210 CG CF = FalseSym0
-      TFHelper_0123456789876543210 CG CG = TrueSym0
-      TFHelper_0123456789876543210 CG CH = FalseSym0
-      TFHelper_0123456789876543210 CG CI = FalseSym0
-      TFHelper_0123456789876543210 CG CJ = FalseSym0
-      TFHelper_0123456789876543210 CG CK = FalseSym0
-      TFHelper_0123456789876543210 CG CL = FalseSym0
-      TFHelper_0123456789876543210 CG CM = FalseSym0
-      TFHelper_0123456789876543210 CG CN = FalseSym0
-      TFHelper_0123456789876543210 CG CO = FalseSym0
-      TFHelper_0123456789876543210 CG CP = FalseSym0
-      TFHelper_0123456789876543210 CG CQ = FalseSym0
-      TFHelper_0123456789876543210 CG CR = FalseSym0
-      TFHelper_0123456789876543210 CG CS = FalseSym0
-      TFHelper_0123456789876543210 CG CT = FalseSym0
-      TFHelper_0123456789876543210 CG CU = FalseSym0
-      TFHelper_0123456789876543210 CG CV = FalseSym0
-      TFHelper_0123456789876543210 CG CW = FalseSym0
-      TFHelper_0123456789876543210 CG CX = FalseSym0
-      TFHelper_0123456789876543210 CG CY = FalseSym0
-      TFHelper_0123456789876543210 CG CZ = FalseSym0
-      TFHelper_0123456789876543210 CH CA = FalseSym0
-      TFHelper_0123456789876543210 CH CB = FalseSym0
-      TFHelper_0123456789876543210 CH CC = FalseSym0
-      TFHelper_0123456789876543210 CH CD = FalseSym0
-      TFHelper_0123456789876543210 CH CE = FalseSym0
-      TFHelper_0123456789876543210 CH CF = FalseSym0
-      TFHelper_0123456789876543210 CH CG = FalseSym0
-      TFHelper_0123456789876543210 CH CH = TrueSym0
-      TFHelper_0123456789876543210 CH CI = FalseSym0
-      TFHelper_0123456789876543210 CH CJ = FalseSym0
-      TFHelper_0123456789876543210 CH CK = FalseSym0
-      TFHelper_0123456789876543210 CH CL = FalseSym0
-      TFHelper_0123456789876543210 CH CM = FalseSym0
-      TFHelper_0123456789876543210 CH CN = FalseSym0
-      TFHelper_0123456789876543210 CH CO = FalseSym0
-      TFHelper_0123456789876543210 CH CP = FalseSym0
-      TFHelper_0123456789876543210 CH CQ = FalseSym0
-      TFHelper_0123456789876543210 CH CR = FalseSym0
-      TFHelper_0123456789876543210 CH CS = FalseSym0
-      TFHelper_0123456789876543210 CH CT = FalseSym0
-      TFHelper_0123456789876543210 CH CU = FalseSym0
-      TFHelper_0123456789876543210 CH CV = FalseSym0
-      TFHelper_0123456789876543210 CH CW = FalseSym0
-      TFHelper_0123456789876543210 CH CX = FalseSym0
-      TFHelper_0123456789876543210 CH CY = FalseSym0
-      TFHelper_0123456789876543210 CH CZ = FalseSym0
-      TFHelper_0123456789876543210 CI CA = FalseSym0
-      TFHelper_0123456789876543210 CI CB = FalseSym0
-      TFHelper_0123456789876543210 CI CC = FalseSym0
-      TFHelper_0123456789876543210 CI CD = FalseSym0
-      TFHelper_0123456789876543210 CI CE = FalseSym0
-      TFHelper_0123456789876543210 CI CF = FalseSym0
-      TFHelper_0123456789876543210 CI CG = FalseSym0
-      TFHelper_0123456789876543210 CI CH = FalseSym0
-      TFHelper_0123456789876543210 CI CI = TrueSym0
-      TFHelper_0123456789876543210 CI CJ = FalseSym0
-      TFHelper_0123456789876543210 CI CK = FalseSym0
-      TFHelper_0123456789876543210 CI CL = FalseSym0
-      TFHelper_0123456789876543210 CI CM = FalseSym0
-      TFHelper_0123456789876543210 CI CN = FalseSym0
-      TFHelper_0123456789876543210 CI CO = FalseSym0
-      TFHelper_0123456789876543210 CI CP = FalseSym0
-      TFHelper_0123456789876543210 CI CQ = FalseSym0
-      TFHelper_0123456789876543210 CI CR = FalseSym0
-      TFHelper_0123456789876543210 CI CS = FalseSym0
-      TFHelper_0123456789876543210 CI CT = FalseSym0
-      TFHelper_0123456789876543210 CI CU = FalseSym0
-      TFHelper_0123456789876543210 CI CV = FalseSym0
-      TFHelper_0123456789876543210 CI CW = FalseSym0
-      TFHelper_0123456789876543210 CI CX = FalseSym0
-      TFHelper_0123456789876543210 CI CY = FalseSym0
-      TFHelper_0123456789876543210 CI CZ = FalseSym0
-      TFHelper_0123456789876543210 CJ CA = FalseSym0
-      TFHelper_0123456789876543210 CJ CB = FalseSym0
-      TFHelper_0123456789876543210 CJ CC = FalseSym0
-      TFHelper_0123456789876543210 CJ CD = FalseSym0
-      TFHelper_0123456789876543210 CJ CE = FalseSym0
-      TFHelper_0123456789876543210 CJ CF = FalseSym0
-      TFHelper_0123456789876543210 CJ CG = FalseSym0
-      TFHelper_0123456789876543210 CJ CH = FalseSym0
-      TFHelper_0123456789876543210 CJ CI = FalseSym0
-      TFHelper_0123456789876543210 CJ CJ = TrueSym0
-      TFHelper_0123456789876543210 CJ CK = FalseSym0
-      TFHelper_0123456789876543210 CJ CL = FalseSym0
-      TFHelper_0123456789876543210 CJ CM = FalseSym0
-      TFHelper_0123456789876543210 CJ CN = FalseSym0
-      TFHelper_0123456789876543210 CJ CO = FalseSym0
-      TFHelper_0123456789876543210 CJ CP = FalseSym0
-      TFHelper_0123456789876543210 CJ CQ = FalseSym0
-      TFHelper_0123456789876543210 CJ CR = FalseSym0
-      TFHelper_0123456789876543210 CJ CS = FalseSym0
-      TFHelper_0123456789876543210 CJ CT = FalseSym0
-      TFHelper_0123456789876543210 CJ CU = FalseSym0
-      TFHelper_0123456789876543210 CJ CV = FalseSym0
-      TFHelper_0123456789876543210 CJ CW = FalseSym0
-      TFHelper_0123456789876543210 CJ CX = FalseSym0
-      TFHelper_0123456789876543210 CJ CY = FalseSym0
-      TFHelper_0123456789876543210 CJ CZ = FalseSym0
-      TFHelper_0123456789876543210 CK CA = FalseSym0
-      TFHelper_0123456789876543210 CK CB = FalseSym0
-      TFHelper_0123456789876543210 CK CC = FalseSym0
-      TFHelper_0123456789876543210 CK CD = FalseSym0
-      TFHelper_0123456789876543210 CK CE = FalseSym0
-      TFHelper_0123456789876543210 CK CF = FalseSym0
-      TFHelper_0123456789876543210 CK CG = FalseSym0
-      TFHelper_0123456789876543210 CK CH = FalseSym0
-      TFHelper_0123456789876543210 CK CI = FalseSym0
-      TFHelper_0123456789876543210 CK CJ = FalseSym0
-      TFHelper_0123456789876543210 CK CK = TrueSym0
-      TFHelper_0123456789876543210 CK CL = FalseSym0
-      TFHelper_0123456789876543210 CK CM = FalseSym0
-      TFHelper_0123456789876543210 CK CN = FalseSym0
-      TFHelper_0123456789876543210 CK CO = FalseSym0
-      TFHelper_0123456789876543210 CK CP = FalseSym0
-      TFHelper_0123456789876543210 CK CQ = FalseSym0
-      TFHelper_0123456789876543210 CK CR = FalseSym0
-      TFHelper_0123456789876543210 CK CS = FalseSym0
-      TFHelper_0123456789876543210 CK CT = FalseSym0
-      TFHelper_0123456789876543210 CK CU = FalseSym0
-      TFHelper_0123456789876543210 CK CV = FalseSym0
-      TFHelper_0123456789876543210 CK CW = FalseSym0
-      TFHelper_0123456789876543210 CK CX = FalseSym0
-      TFHelper_0123456789876543210 CK CY = FalseSym0
-      TFHelper_0123456789876543210 CK CZ = FalseSym0
-      TFHelper_0123456789876543210 CL CA = FalseSym0
-      TFHelper_0123456789876543210 CL CB = FalseSym0
-      TFHelper_0123456789876543210 CL CC = FalseSym0
-      TFHelper_0123456789876543210 CL CD = FalseSym0
-      TFHelper_0123456789876543210 CL CE = FalseSym0
-      TFHelper_0123456789876543210 CL CF = FalseSym0
-      TFHelper_0123456789876543210 CL CG = FalseSym0
-      TFHelper_0123456789876543210 CL CH = FalseSym0
-      TFHelper_0123456789876543210 CL CI = FalseSym0
-      TFHelper_0123456789876543210 CL CJ = FalseSym0
-      TFHelper_0123456789876543210 CL CK = FalseSym0
-      TFHelper_0123456789876543210 CL CL = TrueSym0
-      TFHelper_0123456789876543210 CL CM = FalseSym0
-      TFHelper_0123456789876543210 CL CN = FalseSym0
-      TFHelper_0123456789876543210 CL CO = FalseSym0
-      TFHelper_0123456789876543210 CL CP = FalseSym0
-      TFHelper_0123456789876543210 CL CQ = FalseSym0
-      TFHelper_0123456789876543210 CL CR = FalseSym0
-      TFHelper_0123456789876543210 CL CS = FalseSym0
-      TFHelper_0123456789876543210 CL CT = FalseSym0
-      TFHelper_0123456789876543210 CL CU = FalseSym0
-      TFHelper_0123456789876543210 CL CV = FalseSym0
-      TFHelper_0123456789876543210 CL CW = FalseSym0
-      TFHelper_0123456789876543210 CL CX = FalseSym0
-      TFHelper_0123456789876543210 CL CY = FalseSym0
-      TFHelper_0123456789876543210 CL CZ = FalseSym0
-      TFHelper_0123456789876543210 CM CA = FalseSym0
-      TFHelper_0123456789876543210 CM CB = FalseSym0
-      TFHelper_0123456789876543210 CM CC = FalseSym0
-      TFHelper_0123456789876543210 CM CD = FalseSym0
-      TFHelper_0123456789876543210 CM CE = FalseSym0
-      TFHelper_0123456789876543210 CM CF = FalseSym0
-      TFHelper_0123456789876543210 CM CG = FalseSym0
-      TFHelper_0123456789876543210 CM CH = FalseSym0
-      TFHelper_0123456789876543210 CM CI = FalseSym0
-      TFHelper_0123456789876543210 CM CJ = FalseSym0
-      TFHelper_0123456789876543210 CM CK = FalseSym0
-      TFHelper_0123456789876543210 CM CL = FalseSym0
-      TFHelper_0123456789876543210 CM CM = TrueSym0
-      TFHelper_0123456789876543210 CM CN = FalseSym0
-      TFHelper_0123456789876543210 CM CO = FalseSym0
-      TFHelper_0123456789876543210 CM CP = FalseSym0
-      TFHelper_0123456789876543210 CM CQ = FalseSym0
-      TFHelper_0123456789876543210 CM CR = FalseSym0
-      TFHelper_0123456789876543210 CM CS = FalseSym0
-      TFHelper_0123456789876543210 CM CT = FalseSym0
-      TFHelper_0123456789876543210 CM CU = FalseSym0
-      TFHelper_0123456789876543210 CM CV = FalseSym0
-      TFHelper_0123456789876543210 CM CW = FalseSym0
-      TFHelper_0123456789876543210 CM CX = FalseSym0
-      TFHelper_0123456789876543210 CM CY = FalseSym0
-      TFHelper_0123456789876543210 CM CZ = FalseSym0
-      TFHelper_0123456789876543210 CN CA = FalseSym0
-      TFHelper_0123456789876543210 CN CB = FalseSym0
-      TFHelper_0123456789876543210 CN CC = FalseSym0
-      TFHelper_0123456789876543210 CN CD = FalseSym0
-      TFHelper_0123456789876543210 CN CE = FalseSym0
-      TFHelper_0123456789876543210 CN CF = FalseSym0
-      TFHelper_0123456789876543210 CN CG = FalseSym0
-      TFHelper_0123456789876543210 CN CH = FalseSym0
-      TFHelper_0123456789876543210 CN CI = FalseSym0
-      TFHelper_0123456789876543210 CN CJ = FalseSym0
-      TFHelper_0123456789876543210 CN CK = FalseSym0
-      TFHelper_0123456789876543210 CN CL = FalseSym0
-      TFHelper_0123456789876543210 CN CM = FalseSym0
-      TFHelper_0123456789876543210 CN CN = TrueSym0
-      TFHelper_0123456789876543210 CN CO = FalseSym0
-      TFHelper_0123456789876543210 CN CP = FalseSym0
-      TFHelper_0123456789876543210 CN CQ = FalseSym0
-      TFHelper_0123456789876543210 CN CR = FalseSym0
-      TFHelper_0123456789876543210 CN CS = FalseSym0
-      TFHelper_0123456789876543210 CN CT = FalseSym0
-      TFHelper_0123456789876543210 CN CU = FalseSym0
-      TFHelper_0123456789876543210 CN CV = FalseSym0
-      TFHelper_0123456789876543210 CN CW = FalseSym0
-      TFHelper_0123456789876543210 CN CX = FalseSym0
-      TFHelper_0123456789876543210 CN CY = FalseSym0
-      TFHelper_0123456789876543210 CN CZ = FalseSym0
-      TFHelper_0123456789876543210 CO CA = FalseSym0
-      TFHelper_0123456789876543210 CO CB = FalseSym0
-      TFHelper_0123456789876543210 CO CC = FalseSym0
-      TFHelper_0123456789876543210 CO CD = FalseSym0
-      TFHelper_0123456789876543210 CO CE = FalseSym0
-      TFHelper_0123456789876543210 CO CF = FalseSym0
-      TFHelper_0123456789876543210 CO CG = FalseSym0
-      TFHelper_0123456789876543210 CO CH = FalseSym0
-      TFHelper_0123456789876543210 CO CI = FalseSym0
-      TFHelper_0123456789876543210 CO CJ = FalseSym0
-      TFHelper_0123456789876543210 CO CK = FalseSym0
-      TFHelper_0123456789876543210 CO CL = FalseSym0
-      TFHelper_0123456789876543210 CO CM = FalseSym0
-      TFHelper_0123456789876543210 CO CN = FalseSym0
-      TFHelper_0123456789876543210 CO CO = TrueSym0
-      TFHelper_0123456789876543210 CO CP = FalseSym0
-      TFHelper_0123456789876543210 CO CQ = FalseSym0
-      TFHelper_0123456789876543210 CO CR = FalseSym0
-      TFHelper_0123456789876543210 CO CS = FalseSym0
-      TFHelper_0123456789876543210 CO CT = FalseSym0
-      TFHelper_0123456789876543210 CO CU = FalseSym0
-      TFHelper_0123456789876543210 CO CV = FalseSym0
-      TFHelper_0123456789876543210 CO CW = FalseSym0
-      TFHelper_0123456789876543210 CO CX = FalseSym0
-      TFHelper_0123456789876543210 CO CY = FalseSym0
-      TFHelper_0123456789876543210 CO CZ = FalseSym0
-      TFHelper_0123456789876543210 CP CA = FalseSym0
-      TFHelper_0123456789876543210 CP CB = FalseSym0
-      TFHelper_0123456789876543210 CP CC = FalseSym0
-      TFHelper_0123456789876543210 CP CD = FalseSym0
-      TFHelper_0123456789876543210 CP CE = FalseSym0
-      TFHelper_0123456789876543210 CP CF = FalseSym0
-      TFHelper_0123456789876543210 CP CG = FalseSym0
-      TFHelper_0123456789876543210 CP CH = FalseSym0
-      TFHelper_0123456789876543210 CP CI = FalseSym0
-      TFHelper_0123456789876543210 CP CJ = FalseSym0
-      TFHelper_0123456789876543210 CP CK = FalseSym0
-      TFHelper_0123456789876543210 CP CL = FalseSym0
-      TFHelper_0123456789876543210 CP CM = FalseSym0
-      TFHelper_0123456789876543210 CP CN = FalseSym0
-      TFHelper_0123456789876543210 CP CO = FalseSym0
-      TFHelper_0123456789876543210 CP CP = TrueSym0
-      TFHelper_0123456789876543210 CP CQ = FalseSym0
-      TFHelper_0123456789876543210 CP CR = FalseSym0
-      TFHelper_0123456789876543210 CP CS = FalseSym0
-      TFHelper_0123456789876543210 CP CT = FalseSym0
-      TFHelper_0123456789876543210 CP CU = FalseSym0
-      TFHelper_0123456789876543210 CP CV = FalseSym0
-      TFHelper_0123456789876543210 CP CW = FalseSym0
-      TFHelper_0123456789876543210 CP CX = FalseSym0
-      TFHelper_0123456789876543210 CP CY = FalseSym0
-      TFHelper_0123456789876543210 CP CZ = FalseSym0
-      TFHelper_0123456789876543210 CQ CA = FalseSym0
-      TFHelper_0123456789876543210 CQ CB = FalseSym0
-      TFHelper_0123456789876543210 CQ CC = FalseSym0
-      TFHelper_0123456789876543210 CQ CD = FalseSym0
-      TFHelper_0123456789876543210 CQ CE = FalseSym0
-      TFHelper_0123456789876543210 CQ CF = FalseSym0
-      TFHelper_0123456789876543210 CQ CG = FalseSym0
-      TFHelper_0123456789876543210 CQ CH = FalseSym0
-      TFHelper_0123456789876543210 CQ CI = FalseSym0
-      TFHelper_0123456789876543210 CQ CJ = FalseSym0
-      TFHelper_0123456789876543210 CQ CK = FalseSym0
-      TFHelper_0123456789876543210 CQ CL = FalseSym0
-      TFHelper_0123456789876543210 CQ CM = FalseSym0
-      TFHelper_0123456789876543210 CQ CN = FalseSym0
-      TFHelper_0123456789876543210 CQ CO = FalseSym0
-      TFHelper_0123456789876543210 CQ CP = FalseSym0
-      TFHelper_0123456789876543210 CQ CQ = TrueSym0
-      TFHelper_0123456789876543210 CQ CR = FalseSym0
-      TFHelper_0123456789876543210 CQ CS = FalseSym0
-      TFHelper_0123456789876543210 CQ CT = FalseSym0
-      TFHelper_0123456789876543210 CQ CU = FalseSym0
-      TFHelper_0123456789876543210 CQ CV = FalseSym0
-      TFHelper_0123456789876543210 CQ CW = FalseSym0
-      TFHelper_0123456789876543210 CQ CX = FalseSym0
-      TFHelper_0123456789876543210 CQ CY = FalseSym0
-      TFHelper_0123456789876543210 CQ CZ = FalseSym0
-      TFHelper_0123456789876543210 CR CA = FalseSym0
-      TFHelper_0123456789876543210 CR CB = FalseSym0
-      TFHelper_0123456789876543210 CR CC = FalseSym0
-      TFHelper_0123456789876543210 CR CD = FalseSym0
-      TFHelper_0123456789876543210 CR CE = FalseSym0
-      TFHelper_0123456789876543210 CR CF = FalseSym0
-      TFHelper_0123456789876543210 CR CG = FalseSym0
-      TFHelper_0123456789876543210 CR CH = FalseSym0
-      TFHelper_0123456789876543210 CR CI = FalseSym0
-      TFHelper_0123456789876543210 CR CJ = FalseSym0
-      TFHelper_0123456789876543210 CR CK = FalseSym0
-      TFHelper_0123456789876543210 CR CL = FalseSym0
-      TFHelper_0123456789876543210 CR CM = FalseSym0
-      TFHelper_0123456789876543210 CR CN = FalseSym0
-      TFHelper_0123456789876543210 CR CO = FalseSym0
-      TFHelper_0123456789876543210 CR CP = FalseSym0
-      TFHelper_0123456789876543210 CR CQ = FalseSym0
-      TFHelper_0123456789876543210 CR CR = TrueSym0
-      TFHelper_0123456789876543210 CR CS = FalseSym0
-      TFHelper_0123456789876543210 CR CT = FalseSym0
-      TFHelper_0123456789876543210 CR CU = FalseSym0
-      TFHelper_0123456789876543210 CR CV = FalseSym0
-      TFHelper_0123456789876543210 CR CW = FalseSym0
-      TFHelper_0123456789876543210 CR CX = FalseSym0
-      TFHelper_0123456789876543210 CR CY = FalseSym0
-      TFHelper_0123456789876543210 CR CZ = FalseSym0
-      TFHelper_0123456789876543210 CS CA = FalseSym0
-      TFHelper_0123456789876543210 CS CB = FalseSym0
-      TFHelper_0123456789876543210 CS CC = FalseSym0
-      TFHelper_0123456789876543210 CS CD = FalseSym0
-      TFHelper_0123456789876543210 CS CE = FalseSym0
-      TFHelper_0123456789876543210 CS CF = FalseSym0
-      TFHelper_0123456789876543210 CS CG = FalseSym0
-      TFHelper_0123456789876543210 CS CH = FalseSym0
-      TFHelper_0123456789876543210 CS CI = FalseSym0
-      TFHelper_0123456789876543210 CS CJ = FalseSym0
-      TFHelper_0123456789876543210 CS CK = FalseSym0
-      TFHelper_0123456789876543210 CS CL = FalseSym0
-      TFHelper_0123456789876543210 CS CM = FalseSym0
-      TFHelper_0123456789876543210 CS CN = FalseSym0
-      TFHelper_0123456789876543210 CS CO = FalseSym0
-      TFHelper_0123456789876543210 CS CP = FalseSym0
-      TFHelper_0123456789876543210 CS CQ = FalseSym0
-      TFHelper_0123456789876543210 CS CR = FalseSym0
-      TFHelper_0123456789876543210 CS CS = TrueSym0
-      TFHelper_0123456789876543210 CS CT = FalseSym0
-      TFHelper_0123456789876543210 CS CU = FalseSym0
-      TFHelper_0123456789876543210 CS CV = FalseSym0
-      TFHelper_0123456789876543210 CS CW = FalseSym0
-      TFHelper_0123456789876543210 CS CX = FalseSym0
-      TFHelper_0123456789876543210 CS CY = FalseSym0
-      TFHelper_0123456789876543210 CS CZ = FalseSym0
-      TFHelper_0123456789876543210 CT CA = FalseSym0
-      TFHelper_0123456789876543210 CT CB = FalseSym0
-      TFHelper_0123456789876543210 CT CC = FalseSym0
-      TFHelper_0123456789876543210 CT CD = FalseSym0
-      TFHelper_0123456789876543210 CT CE = FalseSym0
-      TFHelper_0123456789876543210 CT CF = FalseSym0
-      TFHelper_0123456789876543210 CT CG = FalseSym0
-      TFHelper_0123456789876543210 CT CH = FalseSym0
-      TFHelper_0123456789876543210 CT CI = FalseSym0
-      TFHelper_0123456789876543210 CT CJ = FalseSym0
-      TFHelper_0123456789876543210 CT CK = FalseSym0
-      TFHelper_0123456789876543210 CT CL = FalseSym0
-      TFHelper_0123456789876543210 CT CM = FalseSym0
-      TFHelper_0123456789876543210 CT CN = FalseSym0
-      TFHelper_0123456789876543210 CT CO = FalseSym0
-      TFHelper_0123456789876543210 CT CP = FalseSym0
-      TFHelper_0123456789876543210 CT CQ = FalseSym0
-      TFHelper_0123456789876543210 CT CR = FalseSym0
-      TFHelper_0123456789876543210 CT CS = FalseSym0
-      TFHelper_0123456789876543210 CT CT = TrueSym0
-      TFHelper_0123456789876543210 CT CU = FalseSym0
-      TFHelper_0123456789876543210 CT CV = FalseSym0
-      TFHelper_0123456789876543210 CT CW = FalseSym0
-      TFHelper_0123456789876543210 CT CX = FalseSym0
-      TFHelper_0123456789876543210 CT CY = FalseSym0
-      TFHelper_0123456789876543210 CT CZ = FalseSym0
-      TFHelper_0123456789876543210 CU CA = FalseSym0
-      TFHelper_0123456789876543210 CU CB = FalseSym0
-      TFHelper_0123456789876543210 CU CC = FalseSym0
-      TFHelper_0123456789876543210 CU CD = FalseSym0
-      TFHelper_0123456789876543210 CU CE = FalseSym0
-      TFHelper_0123456789876543210 CU CF = FalseSym0
-      TFHelper_0123456789876543210 CU CG = FalseSym0
-      TFHelper_0123456789876543210 CU CH = FalseSym0
-      TFHelper_0123456789876543210 CU CI = FalseSym0
-      TFHelper_0123456789876543210 CU CJ = FalseSym0
-      TFHelper_0123456789876543210 CU CK = FalseSym0
-      TFHelper_0123456789876543210 CU CL = FalseSym0
-      TFHelper_0123456789876543210 CU CM = FalseSym0
-      TFHelper_0123456789876543210 CU CN = FalseSym0
-      TFHelper_0123456789876543210 CU CO = FalseSym0
-      TFHelper_0123456789876543210 CU CP = FalseSym0
-      TFHelper_0123456789876543210 CU CQ = FalseSym0
-      TFHelper_0123456789876543210 CU CR = FalseSym0
-      TFHelper_0123456789876543210 CU CS = FalseSym0
-      TFHelper_0123456789876543210 CU CT = FalseSym0
-      TFHelper_0123456789876543210 CU CU = TrueSym0
-      TFHelper_0123456789876543210 CU CV = FalseSym0
-      TFHelper_0123456789876543210 CU CW = FalseSym0
-      TFHelper_0123456789876543210 CU CX = FalseSym0
-      TFHelper_0123456789876543210 CU CY = FalseSym0
-      TFHelper_0123456789876543210 CU CZ = FalseSym0
-      TFHelper_0123456789876543210 CV CA = FalseSym0
-      TFHelper_0123456789876543210 CV CB = FalseSym0
-      TFHelper_0123456789876543210 CV CC = FalseSym0
-      TFHelper_0123456789876543210 CV CD = FalseSym0
-      TFHelper_0123456789876543210 CV CE = FalseSym0
-      TFHelper_0123456789876543210 CV CF = FalseSym0
-      TFHelper_0123456789876543210 CV CG = FalseSym0
-      TFHelper_0123456789876543210 CV CH = FalseSym0
-      TFHelper_0123456789876543210 CV CI = FalseSym0
-      TFHelper_0123456789876543210 CV CJ = FalseSym0
-      TFHelper_0123456789876543210 CV CK = FalseSym0
-      TFHelper_0123456789876543210 CV CL = FalseSym0
-      TFHelper_0123456789876543210 CV CM = FalseSym0
-      TFHelper_0123456789876543210 CV CN = FalseSym0
-      TFHelper_0123456789876543210 CV CO = FalseSym0
-      TFHelper_0123456789876543210 CV CP = FalseSym0
-      TFHelper_0123456789876543210 CV CQ = FalseSym0
-      TFHelper_0123456789876543210 CV CR = FalseSym0
-      TFHelper_0123456789876543210 CV CS = FalseSym0
-      TFHelper_0123456789876543210 CV CT = FalseSym0
-      TFHelper_0123456789876543210 CV CU = FalseSym0
-      TFHelper_0123456789876543210 CV CV = TrueSym0
-      TFHelper_0123456789876543210 CV CW = FalseSym0
-      TFHelper_0123456789876543210 CV CX = FalseSym0
-      TFHelper_0123456789876543210 CV CY = FalseSym0
-      TFHelper_0123456789876543210 CV CZ = FalseSym0
-      TFHelper_0123456789876543210 CW CA = FalseSym0
-      TFHelper_0123456789876543210 CW CB = FalseSym0
-      TFHelper_0123456789876543210 CW CC = FalseSym0
-      TFHelper_0123456789876543210 CW CD = FalseSym0
-      TFHelper_0123456789876543210 CW CE = FalseSym0
-      TFHelper_0123456789876543210 CW CF = FalseSym0
-      TFHelper_0123456789876543210 CW CG = FalseSym0
-      TFHelper_0123456789876543210 CW CH = FalseSym0
-      TFHelper_0123456789876543210 CW CI = FalseSym0
-      TFHelper_0123456789876543210 CW CJ = FalseSym0
-      TFHelper_0123456789876543210 CW CK = FalseSym0
-      TFHelper_0123456789876543210 CW CL = FalseSym0
-      TFHelper_0123456789876543210 CW CM = FalseSym0
-      TFHelper_0123456789876543210 CW CN = FalseSym0
-      TFHelper_0123456789876543210 CW CO = FalseSym0
-      TFHelper_0123456789876543210 CW CP = FalseSym0
-      TFHelper_0123456789876543210 CW CQ = FalseSym0
-      TFHelper_0123456789876543210 CW CR = FalseSym0
-      TFHelper_0123456789876543210 CW CS = FalseSym0
-      TFHelper_0123456789876543210 CW CT = FalseSym0
-      TFHelper_0123456789876543210 CW CU = FalseSym0
-      TFHelper_0123456789876543210 CW CV = FalseSym0
-      TFHelper_0123456789876543210 CW CW = TrueSym0
-      TFHelper_0123456789876543210 CW CX = FalseSym0
-      TFHelper_0123456789876543210 CW CY = FalseSym0
-      TFHelper_0123456789876543210 CW CZ = FalseSym0
-      TFHelper_0123456789876543210 CX CA = FalseSym0
-      TFHelper_0123456789876543210 CX CB = FalseSym0
-      TFHelper_0123456789876543210 CX CC = FalseSym0
-      TFHelper_0123456789876543210 CX CD = FalseSym0
-      TFHelper_0123456789876543210 CX CE = FalseSym0
-      TFHelper_0123456789876543210 CX CF = FalseSym0
-      TFHelper_0123456789876543210 CX CG = FalseSym0
-      TFHelper_0123456789876543210 CX CH = FalseSym0
-      TFHelper_0123456789876543210 CX CI = FalseSym0
-      TFHelper_0123456789876543210 CX CJ = FalseSym0
-      TFHelper_0123456789876543210 CX CK = FalseSym0
-      TFHelper_0123456789876543210 CX CL = FalseSym0
-      TFHelper_0123456789876543210 CX CM = FalseSym0
-      TFHelper_0123456789876543210 CX CN = FalseSym0
-      TFHelper_0123456789876543210 CX CO = FalseSym0
-      TFHelper_0123456789876543210 CX CP = FalseSym0
-      TFHelper_0123456789876543210 CX CQ = FalseSym0
-      TFHelper_0123456789876543210 CX CR = FalseSym0
-      TFHelper_0123456789876543210 CX CS = FalseSym0
-      TFHelper_0123456789876543210 CX CT = FalseSym0
-      TFHelper_0123456789876543210 CX CU = FalseSym0
-      TFHelper_0123456789876543210 CX CV = FalseSym0
-      TFHelper_0123456789876543210 CX CW = FalseSym0
-      TFHelper_0123456789876543210 CX CX = TrueSym0
-      TFHelper_0123456789876543210 CX CY = FalseSym0
-      TFHelper_0123456789876543210 CX CZ = FalseSym0
-      TFHelper_0123456789876543210 CY CA = FalseSym0
-      TFHelper_0123456789876543210 CY CB = FalseSym0
-      TFHelper_0123456789876543210 CY CC = FalseSym0
-      TFHelper_0123456789876543210 CY CD = FalseSym0
-      TFHelper_0123456789876543210 CY CE = FalseSym0
-      TFHelper_0123456789876543210 CY CF = FalseSym0
-      TFHelper_0123456789876543210 CY CG = FalseSym0
-      TFHelper_0123456789876543210 CY CH = FalseSym0
-      TFHelper_0123456789876543210 CY CI = FalseSym0
-      TFHelper_0123456789876543210 CY CJ = FalseSym0
-      TFHelper_0123456789876543210 CY CK = FalseSym0
-      TFHelper_0123456789876543210 CY CL = FalseSym0
-      TFHelper_0123456789876543210 CY CM = FalseSym0
-      TFHelper_0123456789876543210 CY CN = FalseSym0
-      TFHelper_0123456789876543210 CY CO = FalseSym0
-      TFHelper_0123456789876543210 CY CP = FalseSym0
-      TFHelper_0123456789876543210 CY CQ = FalseSym0
-      TFHelper_0123456789876543210 CY CR = FalseSym0
-      TFHelper_0123456789876543210 CY CS = FalseSym0
-      TFHelper_0123456789876543210 CY CT = FalseSym0
-      TFHelper_0123456789876543210 CY CU = FalseSym0
-      TFHelper_0123456789876543210 CY CV = FalseSym0
-      TFHelper_0123456789876543210 CY CW = FalseSym0
-      TFHelper_0123456789876543210 CY CX = FalseSym0
-      TFHelper_0123456789876543210 CY CY = TrueSym0
-      TFHelper_0123456789876543210 CY CZ = FalseSym0
-      TFHelper_0123456789876543210 CZ CA = FalseSym0
-      TFHelper_0123456789876543210 CZ CB = FalseSym0
-      TFHelper_0123456789876543210 CZ CC = FalseSym0
-      TFHelper_0123456789876543210 CZ CD = FalseSym0
-      TFHelper_0123456789876543210 CZ CE = FalseSym0
-      TFHelper_0123456789876543210 CZ CF = FalseSym0
-      TFHelper_0123456789876543210 CZ CG = FalseSym0
-      TFHelper_0123456789876543210 CZ CH = FalseSym0
-      TFHelper_0123456789876543210 CZ CI = FalseSym0
-      TFHelper_0123456789876543210 CZ CJ = FalseSym0
-      TFHelper_0123456789876543210 CZ CK = FalseSym0
-      TFHelper_0123456789876543210 CZ CL = FalseSym0
-      TFHelper_0123456789876543210 CZ CM = FalseSym0
-      TFHelper_0123456789876543210 CZ CN = FalseSym0
-      TFHelper_0123456789876543210 CZ CO = FalseSym0
-      TFHelper_0123456789876543210 CZ CP = FalseSym0
-      TFHelper_0123456789876543210 CZ CQ = FalseSym0
-      TFHelper_0123456789876543210 CZ CR = FalseSym0
-      TFHelper_0123456789876543210 CZ CS = FalseSym0
-      TFHelper_0123456789876543210 CZ CT = FalseSym0
-      TFHelper_0123456789876543210 CZ CU = FalseSym0
-      TFHelper_0123456789876543210 CZ CV = FalseSym0
-      TFHelper_0123456789876543210 CZ CW = FalseSym0
-      TFHelper_0123456789876543210 CZ CX = FalseSym0
-      TFHelper_0123456789876543210 CZ CY = FalseSym0
-      TFHelper_0123456789876543210 CZ CZ = TrueSym0
-    type TFHelper_0123456789876543210Sym0 :: (~>) AChar ((~>) AChar Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) AChar ((~>) AChar Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: AChar -> (~>) AChar Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: AChar) :: (~>) AChar Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: AChar -> AChar -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: AChar) (a0123456789876543210 :: AChar) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PEq AChar where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    sLookup ::
-      forall (t :: [AChar]) (t :: Schema). Sing t
-                                           -> Sing t -> Sing (Apply (Apply LookupSym0 t) t :: U)
-    sOccurs ::
-      forall (t :: [AChar]) (t :: Schema). Sing t
-                                           -> Sing t -> Sing (Apply (Apply OccursSym0 t) t :: Bool)
-    sDisjoint ::
-      forall (t :: Schema) (t :: Schema). Sing t
-                                          -> Sing t -> Sing (Apply (Apply DisjointSym0 t) t :: Bool)
-    sAttrNotIn ::
-      forall (t :: Attribute) (t :: Schema). Sing t
-                                             -> Sing t
-                                                -> Sing (Apply (Apply AttrNotInSym0 t) t :: Bool)
-    sAppend ::
-      forall (t :: Schema) (t :: Schema). Sing t
-                                          -> Sing t -> Sing (Apply (Apply AppendSym0 t) t :: Schema)
-    sLookup _ (SSch SNil) = sUndefined
-    sLookup
-      (sName :: Sing name)
-      (SSch (SCons (SAttr (sName' :: Sing name') (sU :: Sing u))
-                   (sAttrs :: Sing attrs)))
-      = let
-          sScrutinee_0123456789876543210 ::
-            Sing @_ (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs)
-          sScrutinee_0123456789876543210
-            = (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sName))
-                sName'
-        in
-          (GHC.Base.id
-             @(Sing (Case_0123456789876543210 name name' u attrs (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs) :: U)))
-            (case sScrutinee_0123456789876543210 of
-               STrue -> sU
-               SFalse
-                 -> (applySing ((applySing ((singFun2 @LookupSym0) sLookup)) sName))
-                      ((applySing ((singFun1 @SchSym0) SSch)) sAttrs))
-    sOccurs _ (SSch SNil) = SFalse
-    sOccurs
-      (sName :: Sing name)
-      (SSch (SCons (SAttr (sName' :: Sing name') _)
-                   (sAttrs :: Sing attrs)))
-      = (applySing
-           ((applySing ((singFun2 @(||@#@$)) (%||)))
-              ((applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sName))
-                 sName')))
-          ((applySing ((applySing ((singFun2 @OccursSym0) sOccurs)) sName))
-             ((applySing ((singFun1 @SchSym0) SSch)) sAttrs))
-    sDisjoint (SSch SNil) _ = STrue
-    sDisjoint
-      (SSch (SCons (sH :: Sing h) (sT :: Sing t)))
-      (sS :: Sing s)
-      = (applySing
-           ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-              ((applySing
-                  ((applySing ((singFun2 @AttrNotInSym0) sAttrNotIn)) sH))
-                 sS)))
-          ((applySing
-              ((applySing ((singFun2 @DisjointSym0) sDisjoint))
-                 ((applySing ((singFun1 @SchSym0) SSch)) sT)))
-             sS)
-    sAttrNotIn _ (SSch SNil) = STrue
-    sAttrNotIn
-      (SAttr (sName :: Sing name) (sU :: Sing u))
-      (SSch (SCons (SAttr (sName' :: Sing name') _) (sT :: Sing t)))
-      = (applySing
-           ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-              ((applySing ((applySing ((singFun2 @(/=@#@$)) (%/=))) sName))
-                 sName')))
-          ((applySing
-              ((applySing ((singFun2 @AttrNotInSym0) sAttrNotIn))
-                 ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sName)) sU)))
-             ((applySing ((singFun1 @SchSym0) SSch)) sT))
-    sAppend (SSch (sS1 :: Sing s1)) (SSch (sS2 :: Sing s2))
-      = (applySing ((singFun1 @SchSym0) SSch))
-          ((applySing ((applySing ((singFun2 @(++@#@$)) (%++))) sS1)) sS2)
-    instance SingI (LookupSym0 :: (~>) [AChar] ((~>) Schema U)) where
-      sing = (singFun2 @LookupSym0) sLookup
-    instance SingI d =>
-             SingI (LookupSym1 (d :: [AChar]) :: (~>) Schema U) where
-      sing = (singFun1 @(LookupSym1 (d :: [AChar]))) (sLookup (sing @d))
-    instance SingI1 (LookupSym1 :: [AChar] -> (~>) Schema U) where
-      liftSing (s :: Sing (d :: [AChar]))
-        = (singFun1 @(LookupSym1 (d :: [AChar]))) (sLookup s)
-    instance SingI (OccursSym0 :: (~>) [AChar] ((~>) Schema Bool)) where
-      sing = (singFun2 @OccursSym0) sOccurs
-    instance SingI d =>
-             SingI (OccursSym1 (d :: [AChar]) :: (~>) Schema Bool) where
-      sing = (singFun1 @(OccursSym1 (d :: [AChar]))) (sOccurs (sing @d))
-    instance SingI1 (OccursSym1 :: [AChar] -> (~>) Schema Bool) where
-      liftSing (s :: Sing (d :: [AChar]))
-        = (singFun1 @(OccursSym1 (d :: [AChar]))) (sOccurs s)
-    instance SingI (DisjointSym0 :: (~>) Schema ((~>) Schema Bool)) where
-      sing = (singFun2 @DisjointSym0) sDisjoint
-    instance SingI d =>
-             SingI (DisjointSym1 (d :: Schema) :: (~>) Schema Bool) where
-      sing
-        = (singFun1 @(DisjointSym1 (d :: Schema))) (sDisjoint (sing @d))
-    instance SingI1 (DisjointSym1 :: Schema -> (~>) Schema Bool) where
-      liftSing (s :: Sing (d :: Schema))
-        = (singFun1 @(DisjointSym1 (d :: Schema))) (sDisjoint s)
-    instance SingI (AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool)) where
-      sing = (singFun2 @AttrNotInSym0) sAttrNotIn
-    instance SingI d =>
-             SingI (AttrNotInSym1 (d :: Attribute) :: (~>) Schema Bool) where
-      sing
-        = (singFun1 @(AttrNotInSym1 (d :: Attribute)))
-            (sAttrNotIn (sing @d))
-    instance SingI1 (AttrNotInSym1 :: Attribute
-                                      -> (~>) Schema Bool) where
-      liftSing (s :: Sing (d :: Attribute))
-        = (singFun1 @(AttrNotInSym1 (d :: Attribute))) (sAttrNotIn s)
-    instance SingI (AppendSym0 :: (~>) Schema ((~>) Schema Schema)) where
-      sing = (singFun2 @AppendSym0) sAppend
-    instance SingI d =>
-             SingI (AppendSym1 (d :: Schema) :: (~>) Schema Schema) where
-      sing = (singFun1 @(AppendSym1 (d :: Schema))) (sAppend (sing @d))
-    instance SingI1 (AppendSym1 :: Schema -> (~>) Schema Schema) where
-      liftSing (s :: Sing (d :: Schema))
-        = (singFun1 @(AppendSym1 (d :: Schema))) (sAppend s)
-    data SU :: U -> Type
-      where
-        SBOOL :: SU (BOOL :: U)
-        SSTRING :: SU (STRING :: U)
-        SNAT :: SU (NAT :: U)
-        SVEC :: forall (n :: U) (n :: Nat).
-                (Sing n) -> (Sing n) -> SU (VEC n n :: U)
-    type instance Sing @U = SU
-    instance SingKind U where
-      type Demote U = U
-      fromSing SBOOL = BOOL
-      fromSing SSTRING = STRING
-      fromSing SNAT = NAT
-      fromSing (SVEC b b) = (VEC (fromSing b)) (fromSing b)
-      toSing BOOL = SomeSing SBOOL
-      toSing STRING = SomeSing SSTRING
-      toSing NAT = SomeSing SNAT
-      toSing (VEC (b :: Demote U) (b :: Demote Nat))
-        = case ((,) (toSing b :: SomeSing U)) (toSing b :: SomeSing Nat) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SVEC c) c)
-    data SAChar :: AChar -> Type
-      where
-        SCA :: SAChar (CA :: AChar)
-        SCB :: SAChar (CB :: AChar)
-        SCC :: SAChar (CC :: AChar)
-        SCD :: SAChar (CD :: AChar)
-        SCE :: SAChar (CE :: AChar)
-        SCF :: SAChar (CF :: AChar)
-        SCG :: SAChar (CG :: AChar)
-        SCH :: SAChar (CH :: AChar)
-        SCI :: SAChar (CI :: AChar)
-        SCJ :: SAChar (CJ :: AChar)
-        SCK :: SAChar (CK :: AChar)
-        SCL :: SAChar (CL :: AChar)
-        SCM :: SAChar (CM :: AChar)
-        SCN :: SAChar (CN :: AChar)
-        SCO :: SAChar (CO :: AChar)
-        SCP :: SAChar (CP :: AChar)
-        SCQ :: SAChar (CQ :: AChar)
-        SCR :: SAChar (CR :: AChar)
-        SCS :: SAChar (CS :: AChar)
-        SCT :: SAChar (CT :: AChar)
-        SCU :: SAChar (CU :: AChar)
-        SCV :: SAChar (CV :: AChar)
-        SCW :: SAChar (CW :: AChar)
-        SCX :: SAChar (CX :: AChar)
-        SCY :: SAChar (CY :: AChar)
-        SCZ :: SAChar (CZ :: AChar)
-    type instance Sing @AChar = SAChar
-    instance SingKind AChar where
-      type Demote AChar = AChar
-      fromSing SCA = CA
-      fromSing SCB = CB
-      fromSing SCC = CC
-      fromSing SCD = CD
-      fromSing SCE = CE
-      fromSing SCF = CF
-      fromSing SCG = CG
-      fromSing SCH = CH
-      fromSing SCI = CI
-      fromSing SCJ = CJ
-      fromSing SCK = CK
-      fromSing SCL = CL
-      fromSing SCM = CM
-      fromSing SCN = CN
-      fromSing SCO = CO
-      fromSing SCP = CP
-      fromSing SCQ = CQ
-      fromSing SCR = CR
-      fromSing SCS = CS
-      fromSing SCT = CT
-      fromSing SCU = CU
-      fromSing SCV = CV
-      fromSing SCW = CW
-      fromSing SCX = CX
-      fromSing SCY = CY
-      fromSing SCZ = CZ
-      toSing CA = SomeSing SCA
-      toSing CB = SomeSing SCB
-      toSing CC = SomeSing SCC
-      toSing CD = SomeSing SCD
-      toSing CE = SomeSing SCE
-      toSing CF = SomeSing SCF
-      toSing CG = SomeSing SCG
-      toSing CH = SomeSing SCH
-      toSing CI = SomeSing SCI
-      toSing CJ = SomeSing SCJ
-      toSing CK = SomeSing SCK
-      toSing CL = SomeSing SCL
-      toSing CM = SomeSing SCM
-      toSing CN = SomeSing SCN
-      toSing CO = SomeSing SCO
-      toSing CP = SomeSing SCP
-      toSing CQ = SomeSing SCQ
-      toSing CR = SomeSing SCR
-      toSing CS = SomeSing SCS
-      toSing CT = SomeSing SCT
-      toSing CU = SomeSing SCU
-      toSing CV = SomeSing SCV
-      toSing CW = SomeSing SCW
-      toSing CX = SomeSing SCX
-      toSing CY = SomeSing SCY
-      toSing CZ = SomeSing SCZ
-    data SAttribute :: Attribute -> Type
-      where
-        SAttr :: forall (n :: [AChar]) (n :: U).
-                 (Sing n) -> (Sing n) -> SAttribute (Attr n n :: Attribute)
-    type instance Sing @Attribute = SAttribute
-    instance SingKind Attribute where
-      type Demote Attribute = Attribute
-      fromSing (SAttr b b) = (Attr (fromSing b)) (fromSing b)
-      toSing (Attr (b :: Demote [AChar]) (b :: Demote U))
-        = case
-              ((,) (toSing b :: SomeSing [AChar])) (toSing b :: SomeSing U)
-          of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SAttr c) c)
-    data SSchema :: Schema -> Type
-      where
-        SSch :: forall (n :: [Attribute]).
-                (Sing n) -> SSchema (Sch n :: Schema)
-    type instance Sing @Schema = SSchema
-    instance SingKind Schema where
-      type Demote Schema = Schema
-      fromSing (SSch b) = Sch (fromSing b)
-      toSing (Sch (b :: Demote [Attribute]))
-        = case toSing b :: SomeSing [Attribute] of
-            SomeSing c -> SomeSing (SSch c)
-    instance (SEq U, SEq Nat) => SEq U where
-      (%==) ::
-        forall (t1 :: U) (t2 :: U). Sing t1
-                                    -> Sing t2
-                                       -> Sing (Apply (Apply ((==@#@$) :: TyFun U ((~>) U Bool)
-                                                                          -> Type) t1) t2)
-      (%==) SBOOL SBOOL = STrue
-      (%==) SBOOL SSTRING = SFalse
-      (%==) SBOOL SNAT = SFalse
-      (%==) SBOOL (SVEC _ _) = SFalse
-      (%==) SSTRING SBOOL = SFalse
-      (%==) SSTRING SSTRING = STrue
-      (%==) SSTRING SNAT = SFalse
-      (%==) SSTRING (SVEC _ _) = SFalse
-      (%==) SNAT SBOOL = SFalse
-      (%==) SNAT SSTRING = SFalse
-      (%==) SNAT SNAT = STrue
-      (%==) SNAT (SVEC _ _) = SFalse
-      (%==) (SVEC _ _) SBOOL = SFalse
-      (%==) (SVEC _ _) SSTRING = SFalse
-      (%==) (SVEC _ _) SNAT = SFalse
-      (%==)
-        (SVEC (sA_0123456789876543210 :: Sing a_0123456789876543210)
-              (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SVEC (sB_0123456789876543210 :: Sing b_0123456789876543210)
-              (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                ((applySing
-                    ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                   sB_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-               sB_0123456789876543210)
-    instance (SShow U, SShow Nat) => SShow U where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: U)
-               (t3 :: Symbol). Sing t1
-                               -> Sing t2
-                                  -> Sing t3
-                                     -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) U ((~>) Symbol Symbol))
-                                                                                    -> Type) t1) t2) t3)
-      sShowsPrec
-        _
-        SBOOL
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "BOOL")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SSTRING
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "STRING")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SNAT
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "NAT")))
-            sA_0123456789876543210
-      sShowsPrec
-        (sP_0123456789876543210 :: Sing p_0123456789876543210)
-        (SVEC (sArg_0123456789876543210 :: Sing arg_0123456789876543210)
-              (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "VEC "))))
-                   ((applySing
-                       ((applySing ((singFun3 @(.@#@$)) (%.)))
-                          ((applySing
-                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                 (sFromInteger (sing :: Sing 11))))
-                             sArg_0123456789876543210)))
-                      ((applySing
-                          ((applySing ((singFun3 @(.@#@$)) (%.)))
-                             ((singFun1 @ShowSpaceSym0) sShowSpace)))
-                         ((applySing
-                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                (sFromInteger (sing :: Sing 11))))
-                            sArg_0123456789876543210))))))
-            sA_0123456789876543210
-    instance SShow AChar where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: AChar)
-               (t3 :: Symbol). Sing t1
-                               -> Sing t2
-                                  -> Sing t3
-                                     -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) AChar ((~>) Symbol Symbol))
-                                                                                    -> Type) t1) t2) t3)
-      sShowsPrec
-        _
-        SCA
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CA")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCB
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CB")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCC
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CC")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCD
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CD")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCE
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CE")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCF
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CF")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCG
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CG")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCH
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CH")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCI
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CI")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCJ
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CJ")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCK
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CK")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCL
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CL")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCM
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CM")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCN
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CN")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCO
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CO")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCP
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CP")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCQ
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CQ")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCR
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CR")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCS
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CS")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCT
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CT")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCU
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CU")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCV
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CV")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCW
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CW")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCX
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CX")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCY
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CY")))
-            sA_0123456789876543210
-      sShowsPrec
-        _
-        SCZ
-        (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "CZ")))
-            sA_0123456789876543210
-    instance SEq AChar where
-      (%==) ::
-        forall (t1 :: AChar) (t2 :: AChar). Sing t1
-                                            -> Sing t2
-                                               -> Sing (Apply (Apply ((==@#@$) :: TyFun AChar ((~>) AChar Bool)
-                                                                                  -> Type) t1) t2)
-      (%==) SCA SCA = STrue
-      (%==) SCA SCB = SFalse
-      (%==) SCA SCC = SFalse
-      (%==) SCA SCD = SFalse
-      (%==) SCA SCE = SFalse
-      (%==) SCA SCF = SFalse
-      (%==) SCA SCG = SFalse
-      (%==) SCA SCH = SFalse
-      (%==) SCA SCI = SFalse
-      (%==) SCA SCJ = SFalse
-      (%==) SCA SCK = SFalse
-      (%==) SCA SCL = SFalse
-      (%==) SCA SCM = SFalse
-      (%==) SCA SCN = SFalse
-      (%==) SCA SCO = SFalse
-      (%==) SCA SCP = SFalse
-      (%==) SCA SCQ = SFalse
-      (%==) SCA SCR = SFalse
-      (%==) SCA SCS = SFalse
-      (%==) SCA SCT = SFalse
-      (%==) SCA SCU = SFalse
-      (%==) SCA SCV = SFalse
-      (%==) SCA SCW = SFalse
-      (%==) SCA SCX = SFalse
-      (%==) SCA SCY = SFalse
-      (%==) SCA SCZ = SFalse
-      (%==) SCB SCA = SFalse
-      (%==) SCB SCB = STrue
-      (%==) SCB SCC = SFalse
-      (%==) SCB SCD = SFalse
-      (%==) SCB SCE = SFalse
-      (%==) SCB SCF = SFalse
-      (%==) SCB SCG = SFalse
-      (%==) SCB SCH = SFalse
-      (%==) SCB SCI = SFalse
-      (%==) SCB SCJ = SFalse
-      (%==) SCB SCK = SFalse
-      (%==) SCB SCL = SFalse
-      (%==) SCB SCM = SFalse
-      (%==) SCB SCN = SFalse
-      (%==) SCB SCO = SFalse
-      (%==) SCB SCP = SFalse
-      (%==) SCB SCQ = SFalse
-      (%==) SCB SCR = SFalse
-      (%==) SCB SCS = SFalse
-      (%==) SCB SCT = SFalse
-      (%==) SCB SCU = SFalse
-      (%==) SCB SCV = SFalse
-      (%==) SCB SCW = SFalse
-      (%==) SCB SCX = SFalse
-      (%==) SCB SCY = SFalse
-      (%==) SCB SCZ = SFalse
-      (%==) SCC SCA = SFalse
-      (%==) SCC SCB = SFalse
-      (%==) SCC SCC = STrue
-      (%==) SCC SCD = SFalse
-      (%==) SCC SCE = SFalse
-      (%==) SCC SCF = SFalse
-      (%==) SCC SCG = SFalse
-      (%==) SCC SCH = SFalse
-      (%==) SCC SCI = SFalse
-      (%==) SCC SCJ = SFalse
-      (%==) SCC SCK = SFalse
-      (%==) SCC SCL = SFalse
-      (%==) SCC SCM = SFalse
-      (%==) SCC SCN = SFalse
-      (%==) SCC SCO = SFalse
-      (%==) SCC SCP = SFalse
-      (%==) SCC SCQ = SFalse
-      (%==) SCC SCR = SFalse
-      (%==) SCC SCS = SFalse
-      (%==) SCC SCT = SFalse
-      (%==) SCC SCU = SFalse
-      (%==) SCC SCV = SFalse
-      (%==) SCC SCW = SFalse
-      (%==) SCC SCX = SFalse
-      (%==) SCC SCY = SFalse
-      (%==) SCC SCZ = SFalse
-      (%==) SCD SCA = SFalse
-      (%==) SCD SCB = SFalse
-      (%==) SCD SCC = SFalse
-      (%==) SCD SCD = STrue
-      (%==) SCD SCE = SFalse
-      (%==) SCD SCF = SFalse
-      (%==) SCD SCG = SFalse
-      (%==) SCD SCH = SFalse
-      (%==) SCD SCI = SFalse
-      (%==) SCD SCJ = SFalse
-      (%==) SCD SCK = SFalse
-      (%==) SCD SCL = SFalse
-      (%==) SCD SCM = SFalse
-      (%==) SCD SCN = SFalse
-      (%==) SCD SCO = SFalse
-      (%==) SCD SCP = SFalse
-      (%==) SCD SCQ = SFalse
-      (%==) SCD SCR = SFalse
-      (%==) SCD SCS = SFalse
-      (%==) SCD SCT = SFalse
-      (%==) SCD SCU = SFalse
-      (%==) SCD SCV = SFalse
-      (%==) SCD SCW = SFalse
-      (%==) SCD SCX = SFalse
-      (%==) SCD SCY = SFalse
-      (%==) SCD SCZ = SFalse
-      (%==) SCE SCA = SFalse
-      (%==) SCE SCB = SFalse
-      (%==) SCE SCC = SFalse
-      (%==) SCE SCD = SFalse
-      (%==) SCE SCE = STrue
-      (%==) SCE SCF = SFalse
-      (%==) SCE SCG = SFalse
-      (%==) SCE SCH = SFalse
-      (%==) SCE SCI = SFalse
-      (%==) SCE SCJ = SFalse
-      (%==) SCE SCK = SFalse
-      (%==) SCE SCL = SFalse
-      (%==) SCE SCM = SFalse
-      (%==) SCE SCN = SFalse
-      (%==) SCE SCO = SFalse
-      (%==) SCE SCP = SFalse
-      (%==) SCE SCQ = SFalse
-      (%==) SCE SCR = SFalse
-      (%==) SCE SCS = SFalse
-      (%==) SCE SCT = SFalse
-      (%==) SCE SCU = SFalse
-      (%==) SCE SCV = SFalse
-      (%==) SCE SCW = SFalse
-      (%==) SCE SCX = SFalse
-      (%==) SCE SCY = SFalse
-      (%==) SCE SCZ = SFalse
-      (%==) SCF SCA = SFalse
-      (%==) SCF SCB = SFalse
-      (%==) SCF SCC = SFalse
-      (%==) SCF SCD = SFalse
-      (%==) SCF SCE = SFalse
-      (%==) SCF SCF = STrue
-      (%==) SCF SCG = SFalse
-      (%==) SCF SCH = SFalse
-      (%==) SCF SCI = SFalse
-      (%==) SCF SCJ = SFalse
-      (%==) SCF SCK = SFalse
-      (%==) SCF SCL = SFalse
-      (%==) SCF SCM = SFalse
-      (%==) SCF SCN = SFalse
-      (%==) SCF SCO = SFalse
-      (%==) SCF SCP = SFalse
-      (%==) SCF SCQ = SFalse
-      (%==) SCF SCR = SFalse
-      (%==) SCF SCS = SFalse
-      (%==) SCF SCT = SFalse
-      (%==) SCF SCU = SFalse
-      (%==) SCF SCV = SFalse
-      (%==) SCF SCW = SFalse
-      (%==) SCF SCX = SFalse
-      (%==) SCF SCY = SFalse
-      (%==) SCF SCZ = SFalse
-      (%==) SCG SCA = SFalse
-      (%==) SCG SCB = SFalse
-      (%==) SCG SCC = SFalse
-      (%==) SCG SCD = SFalse
-      (%==) SCG SCE = SFalse
-      (%==) SCG SCF = SFalse
-      (%==) SCG SCG = STrue
-      (%==) SCG SCH = SFalse
-      (%==) SCG SCI = SFalse
-      (%==) SCG SCJ = SFalse
-      (%==) SCG SCK = SFalse
-      (%==) SCG SCL = SFalse
-      (%==) SCG SCM = SFalse
-      (%==) SCG SCN = SFalse
-      (%==) SCG SCO = SFalse
-      (%==) SCG SCP = SFalse
-      (%==) SCG SCQ = SFalse
-      (%==) SCG SCR = SFalse
-      (%==) SCG SCS = SFalse
-      (%==) SCG SCT = SFalse
-      (%==) SCG SCU = SFalse
-      (%==) SCG SCV = SFalse
-      (%==) SCG SCW = SFalse
-      (%==) SCG SCX = SFalse
-      (%==) SCG SCY = SFalse
-      (%==) SCG SCZ = SFalse
-      (%==) SCH SCA = SFalse
-      (%==) SCH SCB = SFalse
-      (%==) SCH SCC = SFalse
-      (%==) SCH SCD = SFalse
-      (%==) SCH SCE = SFalse
-      (%==) SCH SCF = SFalse
-      (%==) SCH SCG = SFalse
-      (%==) SCH SCH = STrue
-      (%==) SCH SCI = SFalse
-      (%==) SCH SCJ = SFalse
-      (%==) SCH SCK = SFalse
-      (%==) SCH SCL = SFalse
-      (%==) SCH SCM = SFalse
-      (%==) SCH SCN = SFalse
-      (%==) SCH SCO = SFalse
-      (%==) SCH SCP = SFalse
-      (%==) SCH SCQ = SFalse
-      (%==) SCH SCR = SFalse
-      (%==) SCH SCS = SFalse
-      (%==) SCH SCT = SFalse
-      (%==) SCH SCU = SFalse
-      (%==) SCH SCV = SFalse
-      (%==) SCH SCW = SFalse
-      (%==) SCH SCX = SFalse
-      (%==) SCH SCY = SFalse
-      (%==) SCH SCZ = SFalse
-      (%==) SCI SCA = SFalse
-      (%==) SCI SCB = SFalse
-      (%==) SCI SCC = SFalse
-      (%==) SCI SCD = SFalse
-      (%==) SCI SCE = SFalse
-      (%==) SCI SCF = SFalse
-      (%==) SCI SCG = SFalse
-      (%==) SCI SCH = SFalse
-      (%==) SCI SCI = STrue
-      (%==) SCI SCJ = SFalse
-      (%==) SCI SCK = SFalse
-      (%==) SCI SCL = SFalse
-      (%==) SCI SCM = SFalse
-      (%==) SCI SCN = SFalse
-      (%==) SCI SCO = SFalse
-      (%==) SCI SCP = SFalse
-      (%==) SCI SCQ = SFalse
-      (%==) SCI SCR = SFalse
-      (%==) SCI SCS = SFalse
-      (%==) SCI SCT = SFalse
-      (%==) SCI SCU = SFalse
-      (%==) SCI SCV = SFalse
-      (%==) SCI SCW = SFalse
-      (%==) SCI SCX = SFalse
-      (%==) SCI SCY = SFalse
-      (%==) SCI SCZ = SFalse
-      (%==) SCJ SCA = SFalse
-      (%==) SCJ SCB = SFalse
-      (%==) SCJ SCC = SFalse
-      (%==) SCJ SCD = SFalse
-      (%==) SCJ SCE = SFalse
-      (%==) SCJ SCF = SFalse
-      (%==) SCJ SCG = SFalse
-      (%==) SCJ SCH = SFalse
-      (%==) SCJ SCI = SFalse
-      (%==) SCJ SCJ = STrue
-      (%==) SCJ SCK = SFalse
-      (%==) SCJ SCL = SFalse
-      (%==) SCJ SCM = SFalse
-      (%==) SCJ SCN = SFalse
-      (%==) SCJ SCO = SFalse
-      (%==) SCJ SCP = SFalse
-      (%==) SCJ SCQ = SFalse
-      (%==) SCJ SCR = SFalse
-      (%==) SCJ SCS = SFalse
-      (%==) SCJ SCT = SFalse
-      (%==) SCJ SCU = SFalse
-      (%==) SCJ SCV = SFalse
-      (%==) SCJ SCW = SFalse
-      (%==) SCJ SCX = SFalse
-      (%==) SCJ SCY = SFalse
-      (%==) SCJ SCZ = SFalse
-      (%==) SCK SCA = SFalse
-      (%==) SCK SCB = SFalse
-      (%==) SCK SCC = SFalse
-      (%==) SCK SCD = SFalse
-      (%==) SCK SCE = SFalse
-      (%==) SCK SCF = SFalse
-      (%==) SCK SCG = SFalse
-      (%==) SCK SCH = SFalse
-      (%==) SCK SCI = SFalse
-      (%==) SCK SCJ = SFalse
-      (%==) SCK SCK = STrue
-      (%==) SCK SCL = SFalse
-      (%==) SCK SCM = SFalse
-      (%==) SCK SCN = SFalse
-      (%==) SCK SCO = SFalse
-      (%==) SCK SCP = SFalse
-      (%==) SCK SCQ = SFalse
-      (%==) SCK SCR = SFalse
-      (%==) SCK SCS = SFalse
-      (%==) SCK SCT = SFalse
-      (%==) SCK SCU = SFalse
-      (%==) SCK SCV = SFalse
-      (%==) SCK SCW = SFalse
-      (%==) SCK SCX = SFalse
-      (%==) SCK SCY = SFalse
-      (%==) SCK SCZ = SFalse
-      (%==) SCL SCA = SFalse
-      (%==) SCL SCB = SFalse
-      (%==) SCL SCC = SFalse
-      (%==) SCL SCD = SFalse
-      (%==) SCL SCE = SFalse
-      (%==) SCL SCF = SFalse
-      (%==) SCL SCG = SFalse
-      (%==) SCL SCH = SFalse
-      (%==) SCL SCI = SFalse
-      (%==) SCL SCJ = SFalse
-      (%==) SCL SCK = SFalse
-      (%==) SCL SCL = STrue
-      (%==) SCL SCM = SFalse
-      (%==) SCL SCN = SFalse
-      (%==) SCL SCO = SFalse
-      (%==) SCL SCP = SFalse
-      (%==) SCL SCQ = SFalse
-      (%==) SCL SCR = SFalse
-      (%==) SCL SCS = SFalse
-      (%==) SCL SCT = SFalse
-      (%==) SCL SCU = SFalse
-      (%==) SCL SCV = SFalse
-      (%==) SCL SCW = SFalse
-      (%==) SCL SCX = SFalse
-      (%==) SCL SCY = SFalse
-      (%==) SCL SCZ = SFalse
-      (%==) SCM SCA = SFalse
-      (%==) SCM SCB = SFalse
-      (%==) SCM SCC = SFalse
-      (%==) SCM SCD = SFalse
-      (%==) SCM SCE = SFalse
-      (%==) SCM SCF = SFalse
-      (%==) SCM SCG = SFalse
-      (%==) SCM SCH = SFalse
-      (%==) SCM SCI = SFalse
-      (%==) SCM SCJ = SFalse
-      (%==) SCM SCK = SFalse
-      (%==) SCM SCL = SFalse
-      (%==) SCM SCM = STrue
-      (%==) SCM SCN = SFalse
-      (%==) SCM SCO = SFalse
-      (%==) SCM SCP = SFalse
-      (%==) SCM SCQ = SFalse
-      (%==) SCM SCR = SFalse
-      (%==) SCM SCS = SFalse
-      (%==) SCM SCT = SFalse
-      (%==) SCM SCU = SFalse
-      (%==) SCM SCV = SFalse
-      (%==) SCM SCW = SFalse
-      (%==) SCM SCX = SFalse
-      (%==) SCM SCY = SFalse
-      (%==) SCM SCZ = SFalse
-      (%==) SCN SCA = SFalse
-      (%==) SCN SCB = SFalse
-      (%==) SCN SCC = SFalse
-      (%==) SCN SCD = SFalse
-      (%==) SCN SCE = SFalse
-      (%==) SCN SCF = SFalse
-      (%==) SCN SCG = SFalse
-      (%==) SCN SCH = SFalse
-      (%==) SCN SCI = SFalse
-      (%==) SCN SCJ = SFalse
-      (%==) SCN SCK = SFalse
-      (%==) SCN SCL = SFalse
-      (%==) SCN SCM = SFalse
-      (%==) SCN SCN = STrue
-      (%==) SCN SCO = SFalse
-      (%==) SCN SCP = SFalse
-      (%==) SCN SCQ = SFalse
-      (%==) SCN SCR = SFalse
-      (%==) SCN SCS = SFalse
-      (%==) SCN SCT = SFalse
-      (%==) SCN SCU = SFalse
-      (%==) SCN SCV = SFalse
-      (%==) SCN SCW = SFalse
-      (%==) SCN SCX = SFalse
-      (%==) SCN SCY = SFalse
-      (%==) SCN SCZ = SFalse
-      (%==) SCO SCA = SFalse
-      (%==) SCO SCB = SFalse
-      (%==) SCO SCC = SFalse
-      (%==) SCO SCD = SFalse
-      (%==) SCO SCE = SFalse
-      (%==) SCO SCF = SFalse
-      (%==) SCO SCG = SFalse
-      (%==) SCO SCH = SFalse
-      (%==) SCO SCI = SFalse
-      (%==) SCO SCJ = SFalse
-      (%==) SCO SCK = SFalse
-      (%==) SCO SCL = SFalse
-      (%==) SCO SCM = SFalse
-      (%==) SCO SCN = SFalse
-      (%==) SCO SCO = STrue
-      (%==) SCO SCP = SFalse
-      (%==) SCO SCQ = SFalse
-      (%==) SCO SCR = SFalse
-      (%==) SCO SCS = SFalse
-      (%==) SCO SCT = SFalse
-      (%==) SCO SCU = SFalse
-      (%==) SCO SCV = SFalse
-      (%==) SCO SCW = SFalse
-      (%==) SCO SCX = SFalse
-      (%==) SCO SCY = SFalse
-      (%==) SCO SCZ = SFalse
-      (%==) SCP SCA = SFalse
-      (%==) SCP SCB = SFalse
-      (%==) SCP SCC = SFalse
-      (%==) SCP SCD = SFalse
-      (%==) SCP SCE = SFalse
-      (%==) SCP SCF = SFalse
-      (%==) SCP SCG = SFalse
-      (%==) SCP SCH = SFalse
-      (%==) SCP SCI = SFalse
-      (%==) SCP SCJ = SFalse
-      (%==) SCP SCK = SFalse
-      (%==) SCP SCL = SFalse
-      (%==) SCP SCM = SFalse
-      (%==) SCP SCN = SFalse
-      (%==) SCP SCO = SFalse
-      (%==) SCP SCP = STrue
-      (%==) SCP SCQ = SFalse
-      (%==) SCP SCR = SFalse
-      (%==) SCP SCS = SFalse
-      (%==) SCP SCT = SFalse
-      (%==) SCP SCU = SFalse
-      (%==) SCP SCV = SFalse
-      (%==) SCP SCW = SFalse
-      (%==) SCP SCX = SFalse
-      (%==) SCP SCY = SFalse
-      (%==) SCP SCZ = SFalse
-      (%==) SCQ SCA = SFalse
-      (%==) SCQ SCB = SFalse
-      (%==) SCQ SCC = SFalse
-      (%==) SCQ SCD = SFalse
-      (%==) SCQ SCE = SFalse
-      (%==) SCQ SCF = SFalse
-      (%==) SCQ SCG = SFalse
-      (%==) SCQ SCH = SFalse
-      (%==) SCQ SCI = SFalse
-      (%==) SCQ SCJ = SFalse
-      (%==) SCQ SCK = SFalse
-      (%==) SCQ SCL = SFalse
-      (%==) SCQ SCM = SFalse
-      (%==) SCQ SCN = SFalse
-      (%==) SCQ SCO = SFalse
-      (%==) SCQ SCP = SFalse
-      (%==) SCQ SCQ = STrue
-      (%==) SCQ SCR = SFalse
-      (%==) SCQ SCS = SFalse
-      (%==) SCQ SCT = SFalse
-      (%==) SCQ SCU = SFalse
-      (%==) SCQ SCV = SFalse
-      (%==) SCQ SCW = SFalse
-      (%==) SCQ SCX = SFalse
-      (%==) SCQ SCY = SFalse
-      (%==) SCQ SCZ = SFalse
-      (%==) SCR SCA = SFalse
-      (%==) SCR SCB = SFalse
-      (%==) SCR SCC = SFalse
-      (%==) SCR SCD = SFalse
-      (%==) SCR SCE = SFalse
-      (%==) SCR SCF = SFalse
-      (%==) SCR SCG = SFalse
-      (%==) SCR SCH = SFalse
-      (%==) SCR SCI = SFalse
-      (%==) SCR SCJ = SFalse
-      (%==) SCR SCK = SFalse
-      (%==) SCR SCL = SFalse
-      (%==) SCR SCM = SFalse
-      (%==) SCR SCN = SFalse
-      (%==) SCR SCO = SFalse
-      (%==) SCR SCP = SFalse
-      (%==) SCR SCQ = SFalse
-      (%==) SCR SCR = STrue
-      (%==) SCR SCS = SFalse
-      (%==) SCR SCT = SFalse
-      (%==) SCR SCU = SFalse
-      (%==) SCR SCV = SFalse
-      (%==) SCR SCW = SFalse
-      (%==) SCR SCX = SFalse
-      (%==) SCR SCY = SFalse
-      (%==) SCR SCZ = SFalse
-      (%==) SCS SCA = SFalse
-      (%==) SCS SCB = SFalse
-      (%==) SCS SCC = SFalse
-      (%==) SCS SCD = SFalse
-      (%==) SCS SCE = SFalse
-      (%==) SCS SCF = SFalse
-      (%==) SCS SCG = SFalse
-      (%==) SCS SCH = SFalse
-      (%==) SCS SCI = SFalse
-      (%==) SCS SCJ = SFalse
-      (%==) SCS SCK = SFalse
-      (%==) SCS SCL = SFalse
-      (%==) SCS SCM = SFalse
-      (%==) SCS SCN = SFalse
-      (%==) SCS SCO = SFalse
-      (%==) SCS SCP = SFalse
-      (%==) SCS SCQ = SFalse
-      (%==) SCS SCR = SFalse
-      (%==) SCS SCS = STrue
-      (%==) SCS SCT = SFalse
-      (%==) SCS SCU = SFalse
-      (%==) SCS SCV = SFalse
-      (%==) SCS SCW = SFalse
-      (%==) SCS SCX = SFalse
-      (%==) SCS SCY = SFalse
-      (%==) SCS SCZ = SFalse
-      (%==) SCT SCA = SFalse
-      (%==) SCT SCB = SFalse
-      (%==) SCT SCC = SFalse
-      (%==) SCT SCD = SFalse
-      (%==) SCT SCE = SFalse
-      (%==) SCT SCF = SFalse
-      (%==) SCT SCG = SFalse
-      (%==) SCT SCH = SFalse
-      (%==) SCT SCI = SFalse
-      (%==) SCT SCJ = SFalse
-      (%==) SCT SCK = SFalse
-      (%==) SCT SCL = SFalse
-      (%==) SCT SCM = SFalse
-      (%==) SCT SCN = SFalse
-      (%==) SCT SCO = SFalse
-      (%==) SCT SCP = SFalse
-      (%==) SCT SCQ = SFalse
-      (%==) SCT SCR = SFalse
-      (%==) SCT SCS = SFalse
-      (%==) SCT SCT = STrue
-      (%==) SCT SCU = SFalse
-      (%==) SCT SCV = SFalse
-      (%==) SCT SCW = SFalse
-      (%==) SCT SCX = SFalse
-      (%==) SCT SCY = SFalse
-      (%==) SCT SCZ = SFalse
-      (%==) SCU SCA = SFalse
-      (%==) SCU SCB = SFalse
-      (%==) SCU SCC = SFalse
-      (%==) SCU SCD = SFalse
-      (%==) SCU SCE = SFalse
-      (%==) SCU SCF = SFalse
-      (%==) SCU SCG = SFalse
-      (%==) SCU SCH = SFalse
-      (%==) SCU SCI = SFalse
-      (%==) SCU SCJ = SFalse
-      (%==) SCU SCK = SFalse
-      (%==) SCU SCL = SFalse
-      (%==) SCU SCM = SFalse
-      (%==) SCU SCN = SFalse
-      (%==) SCU SCO = SFalse
-      (%==) SCU SCP = SFalse
-      (%==) SCU SCQ = SFalse
-      (%==) SCU SCR = SFalse
-      (%==) SCU SCS = SFalse
-      (%==) SCU SCT = SFalse
-      (%==) SCU SCU = STrue
-      (%==) SCU SCV = SFalse
-      (%==) SCU SCW = SFalse
-      (%==) SCU SCX = SFalse
-      (%==) SCU SCY = SFalse
-      (%==) SCU SCZ = SFalse
-      (%==) SCV SCA = SFalse
-      (%==) SCV SCB = SFalse
-      (%==) SCV SCC = SFalse
-      (%==) SCV SCD = SFalse
-      (%==) SCV SCE = SFalse
-      (%==) SCV SCF = SFalse
-      (%==) SCV SCG = SFalse
-      (%==) SCV SCH = SFalse
-      (%==) SCV SCI = SFalse
-      (%==) SCV SCJ = SFalse
-      (%==) SCV SCK = SFalse
-      (%==) SCV SCL = SFalse
-      (%==) SCV SCM = SFalse
-      (%==) SCV SCN = SFalse
-      (%==) SCV SCO = SFalse
-      (%==) SCV SCP = SFalse
-      (%==) SCV SCQ = SFalse
-      (%==) SCV SCR = SFalse
-      (%==) SCV SCS = SFalse
-      (%==) SCV SCT = SFalse
-      (%==) SCV SCU = SFalse
-      (%==) SCV SCV = STrue
-      (%==) SCV SCW = SFalse
-      (%==) SCV SCX = SFalse
-      (%==) SCV SCY = SFalse
-      (%==) SCV SCZ = SFalse
-      (%==) SCW SCA = SFalse
-      (%==) SCW SCB = SFalse
-      (%==) SCW SCC = SFalse
-      (%==) SCW SCD = SFalse
-      (%==) SCW SCE = SFalse
-      (%==) SCW SCF = SFalse
-      (%==) SCW SCG = SFalse
-      (%==) SCW SCH = SFalse
-      (%==) SCW SCI = SFalse
-      (%==) SCW SCJ = SFalse
-      (%==) SCW SCK = SFalse
-      (%==) SCW SCL = SFalse
-      (%==) SCW SCM = SFalse
-      (%==) SCW SCN = SFalse
-      (%==) SCW SCO = SFalse
-      (%==) SCW SCP = SFalse
-      (%==) SCW SCQ = SFalse
-      (%==) SCW SCR = SFalse
-      (%==) SCW SCS = SFalse
-      (%==) SCW SCT = SFalse
-      (%==) SCW SCU = SFalse
-      (%==) SCW SCV = SFalse
-      (%==) SCW SCW = STrue
-      (%==) SCW SCX = SFalse
-      (%==) SCW SCY = SFalse
-      (%==) SCW SCZ = SFalse
-      (%==) SCX SCA = SFalse
-      (%==) SCX SCB = SFalse
-      (%==) SCX SCC = SFalse
-      (%==) SCX SCD = SFalse
-      (%==) SCX SCE = SFalse
-      (%==) SCX SCF = SFalse
-      (%==) SCX SCG = SFalse
-      (%==) SCX SCH = SFalse
-      (%==) SCX SCI = SFalse
-      (%==) SCX SCJ = SFalse
-      (%==) SCX SCK = SFalse
-      (%==) SCX SCL = SFalse
-      (%==) SCX SCM = SFalse
-      (%==) SCX SCN = SFalse
-      (%==) SCX SCO = SFalse
-      (%==) SCX SCP = SFalse
-      (%==) SCX SCQ = SFalse
-      (%==) SCX SCR = SFalse
-      (%==) SCX SCS = SFalse
-      (%==) SCX SCT = SFalse
-      (%==) SCX SCU = SFalse
-      (%==) SCX SCV = SFalse
-      (%==) SCX SCW = SFalse
-      (%==) SCX SCX = STrue
-      (%==) SCX SCY = SFalse
-      (%==) SCX SCZ = SFalse
-      (%==) SCY SCA = SFalse
-      (%==) SCY SCB = SFalse
-      (%==) SCY SCC = SFalse
-      (%==) SCY SCD = SFalse
-      (%==) SCY SCE = SFalse
-      (%==) SCY SCF = SFalse
-      (%==) SCY SCG = SFalse
-      (%==) SCY SCH = SFalse
-      (%==) SCY SCI = SFalse
-      (%==) SCY SCJ = SFalse
-      (%==) SCY SCK = SFalse
-      (%==) SCY SCL = SFalse
-      (%==) SCY SCM = SFalse
-      (%==) SCY SCN = SFalse
-      (%==) SCY SCO = SFalse
-      (%==) SCY SCP = SFalse
-      (%==) SCY SCQ = SFalse
-      (%==) SCY SCR = SFalse
-      (%==) SCY SCS = SFalse
-      (%==) SCY SCT = SFalse
-      (%==) SCY SCU = SFalse
-      (%==) SCY SCV = SFalse
-      (%==) SCY SCW = SFalse
-      (%==) SCY SCX = SFalse
-      (%==) SCY SCY = STrue
-      (%==) SCY SCZ = SFalse
-      (%==) SCZ SCA = SFalse
-      (%==) SCZ SCB = SFalse
-      (%==) SCZ SCC = SFalse
-      (%==) SCZ SCD = SFalse
-      (%==) SCZ SCE = SFalse
-      (%==) SCZ SCF = SFalse
-      (%==) SCZ SCG = SFalse
-      (%==) SCZ SCH = SFalse
-      (%==) SCZ SCI = SFalse
-      (%==) SCZ SCJ = SFalse
-      (%==) SCZ SCK = SFalse
-      (%==) SCZ SCL = SFalse
-      (%==) SCZ SCM = SFalse
-      (%==) SCZ SCN = SFalse
-      (%==) SCZ SCO = SFalse
-      (%==) SCZ SCP = SFalse
-      (%==) SCZ SCQ = SFalse
-      (%==) SCZ SCR = SFalse
-      (%==) SCZ SCS = SFalse
-      (%==) SCZ SCT = SFalse
-      (%==) SCZ SCU = SFalse
-      (%==) SCZ SCV = SFalse
-      (%==) SCZ SCW = SFalse
-      (%==) SCZ SCX = SFalse
-      (%==) SCZ SCY = SFalse
-      (%==) SCZ SCZ = STrue
-    instance (SDecide U, SDecide Nat) => SDecide U where
-      (%~) SBOOL SBOOL = Proved Refl
-      (%~) SBOOL SSTRING = Disproved (\ x -> case x of {})
-      (%~) SBOOL SNAT = Disproved (\ x -> case x of {})
-      (%~) SBOOL (SVEC _ _) = Disproved (\ x -> case x of {})
-      (%~) SSTRING SBOOL = Disproved (\ x -> case x of {})
-      (%~) SSTRING SSTRING = Proved Refl
-      (%~) SSTRING SNAT = Disproved (\ x -> case x of {})
-      (%~) SSTRING (SVEC _ _) = Disproved (\ x -> case x of {})
-      (%~) SNAT SBOOL = Disproved (\ x -> case x of {})
-      (%~) SNAT SSTRING = Disproved (\ x -> case x of {})
-      (%~) SNAT SNAT = Proved Refl
-      (%~) SNAT (SVEC _ _) = Disproved (\ x -> case x of {})
-      (%~) (SVEC _ _) SBOOL = Disproved (\ x -> case x of {})
-      (%~) (SVEC _ _) SSTRING = Disproved (\ x -> case x of {})
-      (%~) (SVEC _ _) SNAT = Disproved (\ x -> case x of {})
-      (%~) (SVEC a a) (SVEC b b)
-        = case ((,) (((%~) a) b)) (((%~) a) b) of
-            (,) (Proved Refl) (Proved Refl) -> Proved Refl
-            (,) (Disproved contra) _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,) _ (Disproved contra)
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-    instance (SDecide U, SDecide Nat) =>
-             Data.Type.Equality.TestEquality (SU :: U -> Type) where
-      Data.Type.Equality.testEquality
-        = Data.Singletons.Decide.decideEquality
-    instance (SDecide U, SDecide Nat) =>
-             Data.Type.Coercion.TestCoercion (SU :: U -> Type) where
-      Data.Type.Coercion.testCoercion
-        = Data.Singletons.Decide.decideCoercion
-    instance SDecide AChar where
-      (%~) SCA SCA = Proved Refl
-      (%~) SCA SCB = Disproved (\ x -> case x of {})
-      (%~) SCA SCC = Disproved (\ x -> case x of {})
-      (%~) SCA SCD = Disproved (\ x -> case x of {})
-      (%~) SCA SCE = Disproved (\ x -> case x of {})
-      (%~) SCA SCF = Disproved (\ x -> case x of {})
-      (%~) SCA SCG = Disproved (\ x -> case x of {})
-      (%~) SCA SCH = Disproved (\ x -> case x of {})
-      (%~) SCA SCI = Disproved (\ x -> case x of {})
-      (%~) SCA SCJ = Disproved (\ x -> case x of {})
-      (%~) SCA SCK = Disproved (\ x -> case x of {})
-      (%~) SCA SCL = Disproved (\ x -> case x of {})
-      (%~) SCA SCM = Disproved (\ x -> case x of {})
-      (%~) SCA SCN = Disproved (\ x -> case x of {})
-      (%~) SCA SCO = Disproved (\ x -> case x of {})
-      (%~) SCA SCP = Disproved (\ x -> case x of {})
-      (%~) SCA SCQ = Disproved (\ x -> case x of {})
-      (%~) SCA SCR = Disproved (\ x -> case x of {})
-      (%~) SCA SCS = Disproved (\ x -> case x of {})
-      (%~) SCA SCT = Disproved (\ x -> case x of {})
-      (%~) SCA SCU = Disproved (\ x -> case x of {})
-      (%~) SCA SCV = Disproved (\ x -> case x of {})
-      (%~) SCA SCW = Disproved (\ x -> case x of {})
-      (%~) SCA SCX = Disproved (\ x -> case x of {})
-      (%~) SCA SCY = Disproved (\ x -> case x of {})
-      (%~) SCA SCZ = Disproved (\ x -> case x of {})
-      (%~) SCB SCA = Disproved (\ x -> case x of {})
-      (%~) SCB SCB = Proved Refl
-      (%~) SCB SCC = Disproved (\ x -> case x of {})
-      (%~) SCB SCD = Disproved (\ x -> case x of {})
-      (%~) SCB SCE = Disproved (\ x -> case x of {})
-      (%~) SCB SCF = Disproved (\ x -> case x of {})
-      (%~) SCB SCG = Disproved (\ x -> case x of {})
-      (%~) SCB SCH = Disproved (\ x -> case x of {})
-      (%~) SCB SCI = Disproved (\ x -> case x of {})
-      (%~) SCB SCJ = Disproved (\ x -> case x of {})
-      (%~) SCB SCK = Disproved (\ x -> case x of {})
-      (%~) SCB SCL = Disproved (\ x -> case x of {})
-      (%~) SCB SCM = Disproved (\ x -> case x of {})
-      (%~) SCB SCN = Disproved (\ x -> case x of {})
-      (%~) SCB SCO = Disproved (\ x -> case x of {})
-      (%~) SCB SCP = Disproved (\ x -> case x of {})
-      (%~) SCB SCQ = Disproved (\ x -> case x of {})
-      (%~) SCB SCR = Disproved (\ x -> case x of {})
-      (%~) SCB SCS = Disproved (\ x -> case x of {})
-      (%~) SCB SCT = Disproved (\ x -> case x of {})
-      (%~) SCB SCU = Disproved (\ x -> case x of {})
-      (%~) SCB SCV = Disproved (\ x -> case x of {})
-      (%~) SCB SCW = Disproved (\ x -> case x of {})
-      (%~) SCB SCX = Disproved (\ x -> case x of {})
-      (%~) SCB SCY = Disproved (\ x -> case x of {})
-      (%~) SCB SCZ = Disproved (\ x -> case x of {})
-      (%~) SCC SCA = Disproved (\ x -> case x of {})
-      (%~) SCC SCB = Disproved (\ x -> case x of {})
-      (%~) SCC SCC = Proved Refl
-      (%~) SCC SCD = Disproved (\ x -> case x of {})
-      (%~) SCC SCE = Disproved (\ x -> case x of {})
-      (%~) SCC SCF = Disproved (\ x -> case x of {})
-      (%~) SCC SCG = Disproved (\ x -> case x of {})
-      (%~) SCC SCH = Disproved (\ x -> case x of {})
-      (%~) SCC SCI = Disproved (\ x -> case x of {})
-      (%~) SCC SCJ = Disproved (\ x -> case x of {})
-      (%~) SCC SCK = Disproved (\ x -> case x of {})
-      (%~) SCC SCL = Disproved (\ x -> case x of {})
-      (%~) SCC SCM = Disproved (\ x -> case x of {})
-      (%~) SCC SCN = Disproved (\ x -> case x of {})
-      (%~) SCC SCO = Disproved (\ x -> case x of {})
-      (%~) SCC SCP = Disproved (\ x -> case x of {})
-      (%~) SCC SCQ = Disproved (\ x -> case x of {})
-      (%~) SCC SCR = Disproved (\ x -> case x of {})
-      (%~) SCC SCS = Disproved (\ x -> case x of {})
-      (%~) SCC SCT = Disproved (\ x -> case x of {})
-      (%~) SCC SCU = Disproved (\ x -> case x of {})
-      (%~) SCC SCV = Disproved (\ x -> case x of {})
-      (%~) SCC SCW = Disproved (\ x -> case x of {})
-      (%~) SCC SCX = Disproved (\ x -> case x of {})
-      (%~) SCC SCY = Disproved (\ x -> case x of {})
-      (%~) SCC SCZ = Disproved (\ x -> case x of {})
-      (%~) SCD SCA = Disproved (\ x -> case x of {})
-      (%~) SCD SCB = Disproved (\ x -> case x of {})
-      (%~) SCD SCC = Disproved (\ x -> case x of {})
-      (%~) SCD SCD = Proved Refl
-      (%~) SCD SCE = Disproved (\ x -> case x of {})
-      (%~) SCD SCF = Disproved (\ x -> case x of {})
-      (%~) SCD SCG = Disproved (\ x -> case x of {})
-      (%~) SCD SCH = Disproved (\ x -> case x of {})
-      (%~) SCD SCI = Disproved (\ x -> case x of {})
-      (%~) SCD SCJ = Disproved (\ x -> case x of {})
-      (%~) SCD SCK = Disproved (\ x -> case x of {})
-      (%~) SCD SCL = Disproved (\ x -> case x of {})
-      (%~) SCD SCM = Disproved (\ x -> case x of {})
-      (%~) SCD SCN = Disproved (\ x -> case x of {})
-      (%~) SCD SCO = Disproved (\ x -> case x of {})
-      (%~) SCD SCP = Disproved (\ x -> case x of {})
-      (%~) SCD SCQ = Disproved (\ x -> case x of {})
-      (%~) SCD SCR = Disproved (\ x -> case x of {})
-      (%~) SCD SCS = Disproved (\ x -> case x of {})
-      (%~) SCD SCT = Disproved (\ x -> case x of {})
-      (%~) SCD SCU = Disproved (\ x -> case x of {})
-      (%~) SCD SCV = Disproved (\ x -> case x of {})
-      (%~) SCD SCW = Disproved (\ x -> case x of {})
-      (%~) SCD SCX = Disproved (\ x -> case x of {})
-      (%~) SCD SCY = Disproved (\ x -> case x of {})
-      (%~) SCD SCZ = Disproved (\ x -> case x of {})
-      (%~) SCE SCA = Disproved (\ x -> case x of {})
-      (%~) SCE SCB = Disproved (\ x -> case x of {})
-      (%~) SCE SCC = Disproved (\ x -> case x of {})
-      (%~) SCE SCD = Disproved (\ x -> case x of {})
-      (%~) SCE SCE = Proved Refl
-      (%~) SCE SCF = Disproved (\ x -> case x of {})
-      (%~) SCE SCG = Disproved (\ x -> case x of {})
-      (%~) SCE SCH = Disproved (\ x -> case x of {})
-      (%~) SCE SCI = Disproved (\ x -> case x of {})
-      (%~) SCE SCJ = Disproved (\ x -> case x of {})
-      (%~) SCE SCK = Disproved (\ x -> case x of {})
-      (%~) SCE SCL = Disproved (\ x -> case x of {})
-      (%~) SCE SCM = Disproved (\ x -> case x of {})
-      (%~) SCE SCN = Disproved (\ x -> case x of {})
-      (%~) SCE SCO = Disproved (\ x -> case x of {})
-      (%~) SCE SCP = Disproved (\ x -> case x of {})
-      (%~) SCE SCQ = Disproved (\ x -> case x of {})
-      (%~) SCE SCR = Disproved (\ x -> case x of {})
-      (%~) SCE SCS = Disproved (\ x -> case x of {})
-      (%~) SCE SCT = Disproved (\ x -> case x of {})
-      (%~) SCE SCU = Disproved (\ x -> case x of {})
-      (%~) SCE SCV = Disproved (\ x -> case x of {})
-      (%~) SCE SCW = Disproved (\ x -> case x of {})
-      (%~) SCE SCX = Disproved (\ x -> case x of {})
-      (%~) SCE SCY = Disproved (\ x -> case x of {})
-      (%~) SCE SCZ = Disproved (\ x -> case x of {})
-      (%~) SCF SCA = Disproved (\ x -> case x of {})
-      (%~) SCF SCB = Disproved (\ x -> case x of {})
-      (%~) SCF SCC = Disproved (\ x -> case x of {})
-      (%~) SCF SCD = Disproved (\ x -> case x of {})
-      (%~) SCF SCE = Disproved (\ x -> case x of {})
-      (%~) SCF SCF = Proved Refl
-      (%~) SCF SCG = Disproved (\ x -> case x of {})
-      (%~) SCF SCH = Disproved (\ x -> case x of {})
-      (%~) SCF SCI = Disproved (\ x -> case x of {})
-      (%~) SCF SCJ = Disproved (\ x -> case x of {})
-      (%~) SCF SCK = Disproved (\ x -> case x of {})
-      (%~) SCF SCL = Disproved (\ x -> case x of {})
-      (%~) SCF SCM = Disproved (\ x -> case x of {})
-      (%~) SCF SCN = Disproved (\ x -> case x of {})
-      (%~) SCF SCO = Disproved (\ x -> case x of {})
-      (%~) SCF SCP = Disproved (\ x -> case x of {})
-      (%~) SCF SCQ = Disproved (\ x -> case x of {})
-      (%~) SCF SCR = Disproved (\ x -> case x of {})
-      (%~) SCF SCS = Disproved (\ x -> case x of {})
-      (%~) SCF SCT = Disproved (\ x -> case x of {})
-      (%~) SCF SCU = Disproved (\ x -> case x of {})
-      (%~) SCF SCV = Disproved (\ x -> case x of {})
-      (%~) SCF SCW = Disproved (\ x -> case x of {})
-      (%~) SCF SCX = Disproved (\ x -> case x of {})
-      (%~) SCF SCY = Disproved (\ x -> case x of {})
-      (%~) SCF SCZ = Disproved (\ x -> case x of {})
-      (%~) SCG SCA = Disproved (\ x -> case x of {})
-      (%~) SCG SCB = Disproved (\ x -> case x of {})
-      (%~) SCG SCC = Disproved (\ x -> case x of {})
-      (%~) SCG SCD = Disproved (\ x -> case x of {})
-      (%~) SCG SCE = Disproved (\ x -> case x of {})
-      (%~) SCG SCF = Disproved (\ x -> case x of {})
-      (%~) SCG SCG = Proved Refl
-      (%~) SCG SCH = Disproved (\ x -> case x of {})
-      (%~) SCG SCI = Disproved (\ x -> case x of {})
-      (%~) SCG SCJ = Disproved (\ x -> case x of {})
-      (%~) SCG SCK = Disproved (\ x -> case x of {})
-      (%~) SCG SCL = Disproved (\ x -> case x of {})
-      (%~) SCG SCM = Disproved (\ x -> case x of {})
-      (%~) SCG SCN = Disproved (\ x -> case x of {})
-      (%~) SCG SCO = Disproved (\ x -> case x of {})
-      (%~) SCG SCP = Disproved (\ x -> case x of {})
-      (%~) SCG SCQ = Disproved (\ x -> case x of {})
-      (%~) SCG SCR = Disproved (\ x -> case x of {})
-      (%~) SCG SCS = Disproved (\ x -> case x of {})
-      (%~) SCG SCT = Disproved (\ x -> case x of {})
-      (%~) SCG SCU = Disproved (\ x -> case x of {})
-      (%~) SCG SCV = Disproved (\ x -> case x of {})
-      (%~) SCG SCW = Disproved (\ x -> case x of {})
-      (%~) SCG SCX = Disproved (\ x -> case x of {})
-      (%~) SCG SCY = Disproved (\ x -> case x of {})
-      (%~) SCG SCZ = Disproved (\ x -> case x of {})
-      (%~) SCH SCA = Disproved (\ x -> case x of {})
-      (%~) SCH SCB = Disproved (\ x -> case x of {})
-      (%~) SCH SCC = Disproved (\ x -> case x of {})
-      (%~) SCH SCD = Disproved (\ x -> case x of {})
-      (%~) SCH SCE = Disproved (\ x -> case x of {})
-      (%~) SCH SCF = Disproved (\ x -> case x of {})
-      (%~) SCH SCG = Disproved (\ x -> case x of {})
-      (%~) SCH SCH = Proved Refl
-      (%~) SCH SCI = Disproved (\ x -> case x of {})
-      (%~) SCH SCJ = Disproved (\ x -> case x of {})
-      (%~) SCH SCK = Disproved (\ x -> case x of {})
-      (%~) SCH SCL = Disproved (\ x -> case x of {})
-      (%~) SCH SCM = Disproved (\ x -> case x of {})
-      (%~) SCH SCN = Disproved (\ x -> case x of {})
-      (%~) SCH SCO = Disproved (\ x -> case x of {})
-      (%~) SCH SCP = Disproved (\ x -> case x of {})
-      (%~) SCH SCQ = Disproved (\ x -> case x of {})
-      (%~) SCH SCR = Disproved (\ x -> case x of {})
-      (%~) SCH SCS = Disproved (\ x -> case x of {})
-      (%~) SCH SCT = Disproved (\ x -> case x of {})
-      (%~) SCH SCU = Disproved (\ x -> case x of {})
-      (%~) SCH SCV = Disproved (\ x -> case x of {})
-      (%~) SCH SCW = Disproved (\ x -> case x of {})
-      (%~) SCH SCX = Disproved (\ x -> case x of {})
-      (%~) SCH SCY = Disproved (\ x -> case x of {})
-      (%~) SCH SCZ = Disproved (\ x -> case x of {})
-      (%~) SCI SCA = Disproved (\ x -> case x of {})
-      (%~) SCI SCB = Disproved (\ x -> case x of {})
-      (%~) SCI SCC = Disproved (\ x -> case x of {})
-      (%~) SCI SCD = Disproved (\ x -> case x of {})
-      (%~) SCI SCE = Disproved (\ x -> case x of {})
-      (%~) SCI SCF = Disproved (\ x -> case x of {})
-      (%~) SCI SCG = Disproved (\ x -> case x of {})
-      (%~) SCI SCH = Disproved (\ x -> case x of {})
-      (%~) SCI SCI = Proved Refl
-      (%~) SCI SCJ = Disproved (\ x -> case x of {})
-      (%~) SCI SCK = Disproved (\ x -> case x of {})
-      (%~) SCI SCL = Disproved (\ x -> case x of {})
-      (%~) SCI SCM = Disproved (\ x -> case x of {})
-      (%~) SCI SCN = Disproved (\ x -> case x of {})
-      (%~) SCI SCO = Disproved (\ x -> case x of {})
-      (%~) SCI SCP = Disproved (\ x -> case x of {})
-      (%~) SCI SCQ = Disproved (\ x -> case x of {})
-      (%~) SCI SCR = Disproved (\ x -> case x of {})
-      (%~) SCI SCS = Disproved (\ x -> case x of {})
-      (%~) SCI SCT = Disproved (\ x -> case x of {})
-      (%~) SCI SCU = Disproved (\ x -> case x of {})
-      (%~) SCI SCV = Disproved (\ x -> case x of {})
-      (%~) SCI SCW = Disproved (\ x -> case x of {})
-      (%~) SCI SCX = Disproved (\ x -> case x of {})
-      (%~) SCI SCY = Disproved (\ x -> case x of {})
-      (%~) SCI SCZ = Disproved (\ x -> case x of {})
-      (%~) SCJ SCA = Disproved (\ x -> case x of {})
-      (%~) SCJ SCB = Disproved (\ x -> case x of {})
-      (%~) SCJ SCC = Disproved (\ x -> case x of {})
-      (%~) SCJ SCD = Disproved (\ x -> case x of {})
-      (%~) SCJ SCE = Disproved (\ x -> case x of {})
-      (%~) SCJ SCF = Disproved (\ x -> case x of {})
-      (%~) SCJ SCG = Disproved (\ x -> case x of {})
-      (%~) SCJ SCH = Disproved (\ x -> case x of {})
-      (%~) SCJ SCI = Disproved (\ x -> case x of {})
-      (%~) SCJ SCJ = Proved Refl
-      (%~) SCJ SCK = Disproved (\ x -> case x of {})
-      (%~) SCJ SCL = Disproved (\ x -> case x of {})
-      (%~) SCJ SCM = Disproved (\ x -> case x of {})
-      (%~) SCJ SCN = Disproved (\ x -> case x of {})
-      (%~) SCJ SCO = Disproved (\ x -> case x of {})
-      (%~) SCJ SCP = Disproved (\ x -> case x of {})
-      (%~) SCJ SCQ = Disproved (\ x -> case x of {})
-      (%~) SCJ SCR = Disproved (\ x -> case x of {})
-      (%~) SCJ SCS = Disproved (\ x -> case x of {})
-      (%~) SCJ SCT = Disproved (\ x -> case x of {})
-      (%~) SCJ SCU = Disproved (\ x -> case x of {})
-      (%~) SCJ SCV = Disproved (\ x -> case x of {})
-      (%~) SCJ SCW = Disproved (\ x -> case x of {})
-      (%~) SCJ SCX = Disproved (\ x -> case x of {})
-      (%~) SCJ SCY = Disproved (\ x -> case x of {})
-      (%~) SCJ SCZ = Disproved (\ x -> case x of {})
-      (%~) SCK SCA = Disproved (\ x -> case x of {})
-      (%~) SCK SCB = Disproved (\ x -> case x of {})
-      (%~) SCK SCC = Disproved (\ x -> case x of {})
-      (%~) SCK SCD = Disproved (\ x -> case x of {})
-      (%~) SCK SCE = Disproved (\ x -> case x of {})
-      (%~) SCK SCF = Disproved (\ x -> case x of {})
-      (%~) SCK SCG = Disproved (\ x -> case x of {})
-      (%~) SCK SCH = Disproved (\ x -> case x of {})
-      (%~) SCK SCI = Disproved (\ x -> case x of {})
-      (%~) SCK SCJ = Disproved (\ x -> case x of {})
-      (%~) SCK SCK = Proved Refl
-      (%~) SCK SCL = Disproved (\ x -> case x of {})
-      (%~) SCK SCM = Disproved (\ x -> case x of {})
-      (%~) SCK SCN = Disproved (\ x -> case x of {})
-      (%~) SCK SCO = Disproved (\ x -> case x of {})
-      (%~) SCK SCP = Disproved (\ x -> case x of {})
-      (%~) SCK SCQ = Disproved (\ x -> case x of {})
-      (%~) SCK SCR = Disproved (\ x -> case x of {})
-      (%~) SCK SCS = Disproved (\ x -> case x of {})
-      (%~) SCK SCT = Disproved (\ x -> case x of {})
-      (%~) SCK SCU = Disproved (\ x -> case x of {})
-      (%~) SCK SCV = Disproved (\ x -> case x of {})
-      (%~) SCK SCW = Disproved (\ x -> case x of {})
-      (%~) SCK SCX = Disproved (\ x -> case x of {})
-      (%~) SCK SCY = Disproved (\ x -> case x of {})
-      (%~) SCK SCZ = Disproved (\ x -> case x of {})
-      (%~) SCL SCA = Disproved (\ x -> case x of {})
-      (%~) SCL SCB = Disproved (\ x -> case x of {})
-      (%~) SCL SCC = Disproved (\ x -> case x of {})
-      (%~) SCL SCD = Disproved (\ x -> case x of {})
-      (%~) SCL SCE = Disproved (\ x -> case x of {})
-      (%~) SCL SCF = Disproved (\ x -> case x of {})
-      (%~) SCL SCG = Disproved (\ x -> case x of {})
-      (%~) SCL SCH = Disproved (\ x -> case x of {})
-      (%~) SCL SCI = Disproved (\ x -> case x of {})
-      (%~) SCL SCJ = Disproved (\ x -> case x of {})
-      (%~) SCL SCK = Disproved (\ x -> case x of {})
-      (%~) SCL SCL = Proved Refl
-      (%~) SCL SCM = Disproved (\ x -> case x of {})
-      (%~) SCL SCN = Disproved (\ x -> case x of {})
-      (%~) SCL SCO = Disproved (\ x -> case x of {})
-      (%~) SCL SCP = Disproved (\ x -> case x of {})
-      (%~) SCL SCQ = Disproved (\ x -> case x of {})
-      (%~) SCL SCR = Disproved (\ x -> case x of {})
-      (%~) SCL SCS = Disproved (\ x -> case x of {})
-      (%~) SCL SCT = Disproved (\ x -> case x of {})
-      (%~) SCL SCU = Disproved (\ x -> case x of {})
-      (%~) SCL SCV = Disproved (\ x -> case x of {})
-      (%~) SCL SCW = Disproved (\ x -> case x of {})
-      (%~) SCL SCX = Disproved (\ x -> case x of {})
-      (%~) SCL SCY = Disproved (\ x -> case x of {})
-      (%~) SCL SCZ = Disproved (\ x -> case x of {})
-      (%~) SCM SCA = Disproved (\ x -> case x of {})
-      (%~) SCM SCB = Disproved (\ x -> case x of {})
-      (%~) SCM SCC = Disproved (\ x -> case x of {})
-      (%~) SCM SCD = Disproved (\ x -> case x of {})
-      (%~) SCM SCE = Disproved (\ x -> case x of {})
-      (%~) SCM SCF = Disproved (\ x -> case x of {})
-      (%~) SCM SCG = Disproved (\ x -> case x of {})
-      (%~) SCM SCH = Disproved (\ x -> case x of {})
-      (%~) SCM SCI = Disproved (\ x -> case x of {})
-      (%~) SCM SCJ = Disproved (\ x -> case x of {})
-      (%~) SCM SCK = Disproved (\ x -> case x of {})
-      (%~) SCM SCL = Disproved (\ x -> case x of {})
-      (%~) SCM SCM = Proved Refl
-      (%~) SCM SCN = Disproved (\ x -> case x of {})
-      (%~) SCM SCO = Disproved (\ x -> case x of {})
-      (%~) SCM SCP = Disproved (\ x -> case x of {})
-      (%~) SCM SCQ = Disproved (\ x -> case x of {})
-      (%~) SCM SCR = Disproved (\ x -> case x of {})
-      (%~) SCM SCS = Disproved (\ x -> case x of {})
-      (%~) SCM SCT = Disproved (\ x -> case x of {})
-      (%~) SCM SCU = Disproved (\ x -> case x of {})
-      (%~) SCM SCV = Disproved (\ x -> case x of {})
-      (%~) SCM SCW = Disproved (\ x -> case x of {})
-      (%~) SCM SCX = Disproved (\ x -> case x of {})
-      (%~) SCM SCY = Disproved (\ x -> case x of {})
-      (%~) SCM SCZ = Disproved (\ x -> case x of {})
-      (%~) SCN SCA = Disproved (\ x -> case x of {})
-      (%~) SCN SCB = Disproved (\ x -> case x of {})
-      (%~) SCN SCC = Disproved (\ x -> case x of {})
-      (%~) SCN SCD = Disproved (\ x -> case x of {})
-      (%~) SCN SCE = Disproved (\ x -> case x of {})
-      (%~) SCN SCF = Disproved (\ x -> case x of {})
-      (%~) SCN SCG = Disproved (\ x -> case x of {})
-      (%~) SCN SCH = Disproved (\ x -> case x of {})
-      (%~) SCN SCI = Disproved (\ x -> case x of {})
-      (%~) SCN SCJ = Disproved (\ x -> case x of {})
-      (%~) SCN SCK = Disproved (\ x -> case x of {})
-      (%~) SCN SCL = Disproved (\ x -> case x of {})
-      (%~) SCN SCM = Disproved (\ x -> case x of {})
-      (%~) SCN SCN = Proved Refl
-      (%~) SCN SCO = Disproved (\ x -> case x of {})
-      (%~) SCN SCP = Disproved (\ x -> case x of {})
-      (%~) SCN SCQ = Disproved (\ x -> case x of {})
-      (%~) SCN SCR = Disproved (\ x -> case x of {})
-      (%~) SCN SCS = Disproved (\ x -> case x of {})
-      (%~) SCN SCT = Disproved (\ x -> case x of {})
-      (%~) SCN SCU = Disproved (\ x -> case x of {})
-      (%~) SCN SCV = Disproved (\ x -> case x of {})
-      (%~) SCN SCW = Disproved (\ x -> case x of {})
-      (%~) SCN SCX = Disproved (\ x -> case x of {})
-      (%~) SCN SCY = Disproved (\ x -> case x of {})
-      (%~) SCN SCZ = Disproved (\ x -> case x of {})
-      (%~) SCO SCA = Disproved (\ x -> case x of {})
-      (%~) SCO SCB = Disproved (\ x -> case x of {})
-      (%~) SCO SCC = Disproved (\ x -> case x of {})
-      (%~) SCO SCD = Disproved (\ x -> case x of {})
-      (%~) SCO SCE = Disproved (\ x -> case x of {})
-      (%~) SCO SCF = Disproved (\ x -> case x of {})
-      (%~) SCO SCG = Disproved (\ x -> case x of {})
-      (%~) SCO SCH = Disproved (\ x -> case x of {})
-      (%~) SCO SCI = Disproved (\ x -> case x of {})
-      (%~) SCO SCJ = Disproved (\ x -> case x of {})
-      (%~) SCO SCK = Disproved (\ x -> case x of {})
-      (%~) SCO SCL = Disproved (\ x -> case x of {})
-      (%~) SCO SCM = Disproved (\ x -> case x of {})
-      (%~) SCO SCN = Disproved (\ x -> case x of {})
-      (%~) SCO SCO = Proved Refl
-      (%~) SCO SCP = Disproved (\ x -> case x of {})
-      (%~) SCO SCQ = Disproved (\ x -> case x of {})
-      (%~) SCO SCR = Disproved (\ x -> case x of {})
-      (%~) SCO SCS = Disproved (\ x -> case x of {})
-      (%~) SCO SCT = Disproved (\ x -> case x of {})
-      (%~) SCO SCU = Disproved (\ x -> case x of {})
-      (%~) SCO SCV = Disproved (\ x -> case x of {})
-      (%~) SCO SCW = Disproved (\ x -> case x of {})
-      (%~) SCO SCX = Disproved (\ x -> case x of {})
-      (%~) SCO SCY = Disproved (\ x -> case x of {})
-      (%~) SCO SCZ = Disproved (\ x -> case x of {})
-      (%~) SCP SCA = Disproved (\ x -> case x of {})
-      (%~) SCP SCB = Disproved (\ x -> case x of {})
-      (%~) SCP SCC = Disproved (\ x -> case x of {})
-      (%~) SCP SCD = Disproved (\ x -> case x of {})
-      (%~) SCP SCE = Disproved (\ x -> case x of {})
-      (%~) SCP SCF = Disproved (\ x -> case x of {})
-      (%~) SCP SCG = Disproved (\ x -> case x of {})
-      (%~) SCP SCH = Disproved (\ x -> case x of {})
-      (%~) SCP SCI = Disproved (\ x -> case x of {})
-      (%~) SCP SCJ = Disproved (\ x -> case x of {})
-      (%~) SCP SCK = Disproved (\ x -> case x of {})
-      (%~) SCP SCL = Disproved (\ x -> case x of {})
-      (%~) SCP SCM = Disproved (\ x -> case x of {})
-      (%~) SCP SCN = Disproved (\ x -> case x of {})
-      (%~) SCP SCO = Disproved (\ x -> case x of {})
-      (%~) SCP SCP = Proved Refl
-      (%~) SCP SCQ = Disproved (\ x -> case x of {})
-      (%~) SCP SCR = Disproved (\ x -> case x of {})
-      (%~) SCP SCS = Disproved (\ x -> case x of {})
-      (%~) SCP SCT = Disproved (\ x -> case x of {})
-      (%~) SCP SCU = Disproved (\ x -> case x of {})
-      (%~) SCP SCV = Disproved (\ x -> case x of {})
-      (%~) SCP SCW = Disproved (\ x -> case x of {})
-      (%~) SCP SCX = Disproved (\ x -> case x of {})
-      (%~) SCP SCY = Disproved (\ x -> case x of {})
-      (%~) SCP SCZ = Disproved (\ x -> case x of {})
-      (%~) SCQ SCA = Disproved (\ x -> case x of {})
-      (%~) SCQ SCB = Disproved (\ x -> case x of {})
-      (%~) SCQ SCC = Disproved (\ x -> case x of {})
-      (%~) SCQ SCD = Disproved (\ x -> case x of {})
-      (%~) SCQ SCE = Disproved (\ x -> case x of {})
-      (%~) SCQ SCF = Disproved (\ x -> case x of {})
-      (%~) SCQ SCG = Disproved (\ x -> case x of {})
-      (%~) SCQ SCH = Disproved (\ x -> case x of {})
-      (%~) SCQ SCI = Disproved (\ x -> case x of {})
-      (%~) SCQ SCJ = Disproved (\ x -> case x of {})
-      (%~) SCQ SCK = Disproved (\ x -> case x of {})
-      (%~) SCQ SCL = Disproved (\ x -> case x of {})
-      (%~) SCQ SCM = Disproved (\ x -> case x of {})
-      (%~) SCQ SCN = Disproved (\ x -> case x of {})
-      (%~) SCQ SCO = Disproved (\ x -> case x of {})
-      (%~) SCQ SCP = Disproved (\ x -> case x of {})
-      (%~) SCQ SCQ = Proved Refl
-      (%~) SCQ SCR = Disproved (\ x -> case x of {})
-      (%~) SCQ SCS = Disproved (\ x -> case x of {})
-      (%~) SCQ SCT = Disproved (\ x -> case x of {})
-      (%~) SCQ SCU = Disproved (\ x -> case x of {})
-      (%~) SCQ SCV = Disproved (\ x -> case x of {})
-      (%~) SCQ SCW = Disproved (\ x -> case x of {})
-      (%~) SCQ SCX = Disproved (\ x -> case x of {})
-      (%~) SCQ SCY = Disproved (\ x -> case x of {})
-      (%~) SCQ SCZ = Disproved (\ x -> case x of {})
-      (%~) SCR SCA = Disproved (\ x -> case x of {})
-      (%~) SCR SCB = Disproved (\ x -> case x of {})
-      (%~) SCR SCC = Disproved (\ x -> case x of {})
-      (%~) SCR SCD = Disproved (\ x -> case x of {})
-      (%~) SCR SCE = Disproved (\ x -> case x of {})
-      (%~) SCR SCF = Disproved (\ x -> case x of {})
-      (%~) SCR SCG = Disproved (\ x -> case x of {})
-      (%~) SCR SCH = Disproved (\ x -> case x of {})
-      (%~) SCR SCI = Disproved (\ x -> case x of {})
-      (%~) SCR SCJ = Disproved (\ x -> case x of {})
-      (%~) SCR SCK = Disproved (\ x -> case x of {})
-      (%~) SCR SCL = Disproved (\ x -> case x of {})
-      (%~) SCR SCM = Disproved (\ x -> case x of {})
-      (%~) SCR SCN = Disproved (\ x -> case x of {})
-      (%~) SCR SCO = Disproved (\ x -> case x of {})
-      (%~) SCR SCP = Disproved (\ x -> case x of {})
-      (%~) SCR SCQ = Disproved (\ x -> case x of {})
-      (%~) SCR SCR = Proved Refl
-      (%~) SCR SCS = Disproved (\ x -> case x of {})
-      (%~) SCR SCT = Disproved (\ x -> case x of {})
-      (%~) SCR SCU = Disproved (\ x -> case x of {})
-      (%~) SCR SCV = Disproved (\ x -> case x of {})
-      (%~) SCR SCW = Disproved (\ x -> case x of {})
-      (%~) SCR SCX = Disproved (\ x -> case x of {})
-      (%~) SCR SCY = Disproved (\ x -> case x of {})
-      (%~) SCR SCZ = Disproved (\ x -> case x of {})
-      (%~) SCS SCA = Disproved (\ x -> case x of {})
-      (%~) SCS SCB = Disproved (\ x -> case x of {})
-      (%~) SCS SCC = Disproved (\ x -> case x of {})
-      (%~) SCS SCD = Disproved (\ x -> case x of {})
-      (%~) SCS SCE = Disproved (\ x -> case x of {})
-      (%~) SCS SCF = Disproved (\ x -> case x of {})
-      (%~) SCS SCG = Disproved (\ x -> case x of {})
-      (%~) SCS SCH = Disproved (\ x -> case x of {})
-      (%~) SCS SCI = Disproved (\ x -> case x of {})
-      (%~) SCS SCJ = Disproved (\ x -> case x of {})
-      (%~) SCS SCK = Disproved (\ x -> case x of {})
-      (%~) SCS SCL = Disproved (\ x -> case x of {})
-      (%~) SCS SCM = Disproved (\ x -> case x of {})
-      (%~) SCS SCN = Disproved (\ x -> case x of {})
-      (%~) SCS SCO = Disproved (\ x -> case x of {})
-      (%~) SCS SCP = Disproved (\ x -> case x of {})
-      (%~) SCS SCQ = Disproved (\ x -> case x of {})
-      (%~) SCS SCR = Disproved (\ x -> case x of {})
-      (%~) SCS SCS = Proved Refl
-      (%~) SCS SCT = Disproved (\ x -> case x of {})
-      (%~) SCS SCU = Disproved (\ x -> case x of {})
-      (%~) SCS SCV = Disproved (\ x -> case x of {})
-      (%~) SCS SCW = Disproved (\ x -> case x of {})
-      (%~) SCS SCX = Disproved (\ x -> case x of {})
-      (%~) SCS SCY = Disproved (\ x -> case x of {})
-      (%~) SCS SCZ = Disproved (\ x -> case x of {})
-      (%~) SCT SCA = Disproved (\ x -> case x of {})
-      (%~) SCT SCB = Disproved (\ x -> case x of {})
-      (%~) SCT SCC = Disproved (\ x -> case x of {})
-      (%~) SCT SCD = Disproved (\ x -> case x of {})
-      (%~) SCT SCE = Disproved (\ x -> case x of {})
-      (%~) SCT SCF = Disproved (\ x -> case x of {})
-      (%~) SCT SCG = Disproved (\ x -> case x of {})
-      (%~) SCT SCH = Disproved (\ x -> case x of {})
-      (%~) SCT SCI = Disproved (\ x -> case x of {})
-      (%~) SCT SCJ = Disproved (\ x -> case x of {})
-      (%~) SCT SCK = Disproved (\ x -> case x of {})
-      (%~) SCT SCL = Disproved (\ x -> case x of {})
-      (%~) SCT SCM = Disproved (\ x -> case x of {})
-      (%~) SCT SCN = Disproved (\ x -> case x of {})
-      (%~) SCT SCO = Disproved (\ x -> case x of {})
-      (%~) SCT SCP = Disproved (\ x -> case x of {})
-      (%~) SCT SCQ = Disproved (\ x -> case x of {})
-      (%~) SCT SCR = Disproved (\ x -> case x of {})
-      (%~) SCT SCS = Disproved (\ x -> case x of {})
-      (%~) SCT SCT = Proved Refl
-      (%~) SCT SCU = Disproved (\ x -> case x of {})
-      (%~) SCT SCV = Disproved (\ x -> case x of {})
-      (%~) SCT SCW = Disproved (\ x -> case x of {})
-      (%~) SCT SCX = Disproved (\ x -> case x of {})
-      (%~) SCT SCY = Disproved (\ x -> case x of {})
-      (%~) SCT SCZ = Disproved (\ x -> case x of {})
-      (%~) SCU SCA = Disproved (\ x -> case x of {})
-      (%~) SCU SCB = Disproved (\ x -> case x of {})
-      (%~) SCU SCC = Disproved (\ x -> case x of {})
-      (%~) SCU SCD = Disproved (\ x -> case x of {})
-      (%~) SCU SCE = Disproved (\ x -> case x of {})
-      (%~) SCU SCF = Disproved (\ x -> case x of {})
-      (%~) SCU SCG = Disproved (\ x -> case x of {})
-      (%~) SCU SCH = Disproved (\ x -> case x of {})
-      (%~) SCU SCI = Disproved (\ x -> case x of {})
-      (%~) SCU SCJ = Disproved (\ x -> case x of {})
-      (%~) SCU SCK = Disproved (\ x -> case x of {})
-      (%~) SCU SCL = Disproved (\ x -> case x of {})
-      (%~) SCU SCM = Disproved (\ x -> case x of {})
-      (%~) SCU SCN = Disproved (\ x -> case x of {})
-      (%~) SCU SCO = Disproved (\ x -> case x of {})
-      (%~) SCU SCP = Disproved (\ x -> case x of {})
-      (%~) SCU SCQ = Disproved (\ x -> case x of {})
-      (%~) SCU SCR = Disproved (\ x -> case x of {})
-      (%~) SCU SCS = Disproved (\ x -> case x of {})
-      (%~) SCU SCT = Disproved (\ x -> case x of {})
-      (%~) SCU SCU = Proved Refl
-      (%~) SCU SCV = Disproved (\ x -> case x of {})
-      (%~) SCU SCW = Disproved (\ x -> case x of {})
-      (%~) SCU SCX = Disproved (\ x -> case x of {})
-      (%~) SCU SCY = Disproved (\ x -> case x of {})
-      (%~) SCU SCZ = Disproved (\ x -> case x of {})
-      (%~) SCV SCA = Disproved (\ x -> case x of {})
-      (%~) SCV SCB = Disproved (\ x -> case x of {})
-      (%~) SCV SCC = Disproved (\ x -> case x of {})
-      (%~) SCV SCD = Disproved (\ x -> case x of {})
-      (%~) SCV SCE = Disproved (\ x -> case x of {})
-      (%~) SCV SCF = Disproved (\ x -> case x of {})
-      (%~) SCV SCG = Disproved (\ x -> case x of {})
-      (%~) SCV SCH = Disproved (\ x -> case x of {})
-      (%~) SCV SCI = Disproved (\ x -> case x of {})
-      (%~) SCV SCJ = Disproved (\ x -> case x of {})
-      (%~) SCV SCK = Disproved (\ x -> case x of {})
-      (%~) SCV SCL = Disproved (\ x -> case x of {})
-      (%~) SCV SCM = Disproved (\ x -> case x of {})
-      (%~) SCV SCN = Disproved (\ x -> case x of {})
-      (%~) SCV SCO = Disproved (\ x -> case x of {})
-      (%~) SCV SCP = Disproved (\ x -> case x of {})
-      (%~) SCV SCQ = Disproved (\ x -> case x of {})
-      (%~) SCV SCR = Disproved (\ x -> case x of {})
-      (%~) SCV SCS = Disproved (\ x -> case x of {})
-      (%~) SCV SCT = Disproved (\ x -> case x of {})
-      (%~) SCV SCU = Disproved (\ x -> case x of {})
-      (%~) SCV SCV = Proved Refl
-      (%~) SCV SCW = Disproved (\ x -> case x of {})
-      (%~) SCV SCX = Disproved (\ x -> case x of {})
-      (%~) SCV SCY = Disproved (\ x -> case x of {})
-      (%~) SCV SCZ = Disproved (\ x -> case x of {})
-      (%~) SCW SCA = Disproved (\ x -> case x of {})
-      (%~) SCW SCB = Disproved (\ x -> case x of {})
-      (%~) SCW SCC = Disproved (\ x -> case x of {})
-      (%~) SCW SCD = Disproved (\ x -> case x of {})
-      (%~) SCW SCE = Disproved (\ x -> case x of {})
-      (%~) SCW SCF = Disproved (\ x -> case x of {})
-      (%~) SCW SCG = Disproved (\ x -> case x of {})
-      (%~) SCW SCH = Disproved (\ x -> case x of {})
-      (%~) SCW SCI = Disproved (\ x -> case x of {})
-      (%~) SCW SCJ = Disproved (\ x -> case x of {})
-      (%~) SCW SCK = Disproved (\ x -> case x of {})
-      (%~) SCW SCL = Disproved (\ x -> case x of {})
-      (%~) SCW SCM = Disproved (\ x -> case x of {})
-      (%~) SCW SCN = Disproved (\ x -> case x of {})
-      (%~) SCW SCO = Disproved (\ x -> case x of {})
-      (%~) SCW SCP = Disproved (\ x -> case x of {})
-      (%~) SCW SCQ = Disproved (\ x -> case x of {})
-      (%~) SCW SCR = Disproved (\ x -> case x of {})
-      (%~) SCW SCS = Disproved (\ x -> case x of {})
-      (%~) SCW SCT = Disproved (\ x -> case x of {})
-      (%~) SCW SCU = Disproved (\ x -> case x of {})
-      (%~) SCW SCV = Disproved (\ x -> case x of {})
-      (%~) SCW SCW = Proved Refl
-      (%~) SCW SCX = Disproved (\ x -> case x of {})
-      (%~) SCW SCY = Disproved (\ x -> case x of {})
-      (%~) SCW SCZ = Disproved (\ x -> case x of {})
-      (%~) SCX SCA = Disproved (\ x -> case x of {})
-      (%~) SCX SCB = Disproved (\ x -> case x of {})
-      (%~) SCX SCC = Disproved (\ x -> case x of {})
-      (%~) SCX SCD = Disproved (\ x -> case x of {})
-      (%~) SCX SCE = Disproved (\ x -> case x of {})
-      (%~) SCX SCF = Disproved (\ x -> case x of {})
-      (%~) SCX SCG = Disproved (\ x -> case x of {})
-      (%~) SCX SCH = Disproved (\ x -> case x of {})
-      (%~) SCX SCI = Disproved (\ x -> case x of {})
-      (%~) SCX SCJ = Disproved (\ x -> case x of {})
-      (%~) SCX SCK = Disproved (\ x -> case x of {})
-      (%~) SCX SCL = Disproved (\ x -> case x of {})
-      (%~) SCX SCM = Disproved (\ x -> case x of {})
-      (%~) SCX SCN = Disproved (\ x -> case x of {})
-      (%~) SCX SCO = Disproved (\ x -> case x of {})
-      (%~) SCX SCP = Disproved (\ x -> case x of {})
-      (%~) SCX SCQ = Disproved (\ x -> case x of {})
-      (%~) SCX SCR = Disproved (\ x -> case x of {})
-      (%~) SCX SCS = Disproved (\ x -> case x of {})
-      (%~) SCX SCT = Disproved (\ x -> case x of {})
-      (%~) SCX SCU = Disproved (\ x -> case x of {})
-      (%~) SCX SCV = Disproved (\ x -> case x of {})
-      (%~) SCX SCW = Disproved (\ x -> case x of {})
-      (%~) SCX SCX = Proved Refl
-      (%~) SCX SCY = Disproved (\ x -> case x of {})
-      (%~) SCX SCZ = Disproved (\ x -> case x of {})
-      (%~) SCY SCA = Disproved (\ x -> case x of {})
-      (%~) SCY SCB = Disproved (\ x -> case x of {})
-      (%~) SCY SCC = Disproved (\ x -> case x of {})
-      (%~) SCY SCD = Disproved (\ x -> case x of {})
-      (%~) SCY SCE = Disproved (\ x -> case x of {})
-      (%~) SCY SCF = Disproved (\ x -> case x of {})
-      (%~) SCY SCG = Disproved (\ x -> case x of {})
-      (%~) SCY SCH = Disproved (\ x -> case x of {})
-      (%~) SCY SCI = Disproved (\ x -> case x of {})
-      (%~) SCY SCJ = Disproved (\ x -> case x of {})
-      (%~) SCY SCK = Disproved (\ x -> case x of {})
-      (%~) SCY SCL = Disproved (\ x -> case x of {})
-      (%~) SCY SCM = Disproved (\ x -> case x of {})
-      (%~) SCY SCN = Disproved (\ x -> case x of {})
-      (%~) SCY SCO = Disproved (\ x -> case x of {})
-      (%~) SCY SCP = Disproved (\ x -> case x of {})
-      (%~) SCY SCQ = Disproved (\ x -> case x of {})
-      (%~) SCY SCR = Disproved (\ x -> case x of {})
-      (%~) SCY SCS = Disproved (\ x -> case x of {})
-      (%~) SCY SCT = Disproved (\ x -> case x of {})
-      (%~) SCY SCU = Disproved (\ x -> case x of {})
-      (%~) SCY SCV = Disproved (\ x -> case x of {})
-      (%~) SCY SCW = Disproved (\ x -> case x of {})
-      (%~) SCY SCX = Disproved (\ x -> case x of {})
-      (%~) SCY SCY = Proved Refl
-      (%~) SCY SCZ = Disproved (\ x -> case x of {})
-      (%~) SCZ SCA = Disproved (\ x -> case x of {})
-      (%~) SCZ SCB = Disproved (\ x -> case x of {})
-      (%~) SCZ SCC = Disproved (\ x -> case x of {})
-      (%~) SCZ SCD = Disproved (\ x -> case x of {})
-      (%~) SCZ SCE = Disproved (\ x -> case x of {})
-      (%~) SCZ SCF = Disproved (\ x -> case x of {})
-      (%~) SCZ SCG = Disproved (\ x -> case x of {})
-      (%~) SCZ SCH = Disproved (\ x -> case x of {})
-      (%~) SCZ SCI = Disproved (\ x -> case x of {})
-      (%~) SCZ SCJ = Disproved (\ x -> case x of {})
-      (%~) SCZ SCK = Disproved (\ x -> case x of {})
-      (%~) SCZ SCL = Disproved (\ x -> case x of {})
-      (%~) SCZ SCM = Disproved (\ x -> case x of {})
-      (%~) SCZ SCN = Disproved (\ x -> case x of {})
-      (%~) SCZ SCO = Disproved (\ x -> case x of {})
-      (%~) SCZ SCP = Disproved (\ x -> case x of {})
-      (%~) SCZ SCQ = Disproved (\ x -> case x of {})
-      (%~) SCZ SCR = Disproved (\ x -> case x of {})
-      (%~) SCZ SCS = Disproved (\ x -> case x of {})
-      (%~) SCZ SCT = Disproved (\ x -> case x of {})
-      (%~) SCZ SCU = Disproved (\ x -> case x of {})
-      (%~) SCZ SCV = Disproved (\ x -> case x of {})
-      (%~) SCZ SCW = Disproved (\ x -> case x of {})
-      (%~) SCZ SCX = Disproved (\ x -> case x of {})
-      (%~) SCZ SCY = Disproved (\ x -> case x of {})
-      (%~) SCZ SCZ = Proved Refl
-    instance Data.Type.Equality.TestEquality (SAChar :: AChar
-                                                        -> Type) where
-      Data.Type.Equality.testEquality
-        = Data.Singletons.Decide.decideEquality
-    instance Data.Type.Coercion.TestCoercion (SAChar :: AChar
-                                                        -> Type) where
-      Data.Type.Coercion.testCoercion
-        = Data.Singletons.Decide.decideCoercion
-    deriving instance (Data.Singletons.ShowSing.ShowSing U,
-                       Data.Singletons.ShowSing.ShowSing Nat) =>
-                      Show (SU (z :: U))
-    deriving instance Show (SAChar (z :: AChar))
-    instance SingI BOOL where
-      sing = SBOOL
-    instance SingI STRING where
-      sing = SSTRING
-    instance SingI NAT where
-      sing = SNAT
-    instance (SingI n, SingI n) =>
-             SingI (VEC (n :: U) (n :: Nat)) where
-      sing = (SVEC sing) sing
-    instance SingI n => SingI1 (VEC (n :: U)) where
-      liftSing = SVEC sing
-    instance SingI2 VEC where
-      liftSing2 = SVEC
-    instance SingI (VECSym0 :: (~>) U ((~>) Nat U)) where
-      sing = (singFun2 @VECSym0) SVEC
-    instance SingI d => SingI (VECSym1 (d :: U) :: (~>) Nat U) where
-      sing = (singFun1 @(VECSym1 (d :: U))) (SVEC (sing @d))
-    instance SingI1 (VECSym1 :: U -> (~>) Nat U) where
-      liftSing (s :: Sing (d :: U))
-        = (singFun1 @(VECSym1 (d :: U))) (SVEC s)
-    instance SingI CA where
-      sing = SCA
-    instance SingI CB where
-      sing = SCB
-    instance SingI CC where
-      sing = SCC
-    instance SingI CD where
-      sing = SCD
-    instance SingI CE where
-      sing = SCE
-    instance SingI CF where
-      sing = SCF
-    instance SingI CG where
-      sing = SCG
-    instance SingI CH where
-      sing = SCH
-    instance SingI CI where
-      sing = SCI
-    instance SingI CJ where
-      sing = SCJ
-    instance SingI CK where
-      sing = SCK
-    instance SingI CL where
-      sing = SCL
-    instance SingI CM where
-      sing = SCM
-    instance SingI CN where
-      sing = SCN
-    instance SingI CO where
-      sing = SCO
-    instance SingI CP where
-      sing = SCP
-    instance SingI CQ where
-      sing = SCQ
-    instance SingI CR where
-      sing = SCR
-    instance SingI CS where
-      sing = SCS
-    instance SingI CT where
-      sing = SCT
-    instance SingI CU where
-      sing = SCU
-    instance SingI CV where
-      sing = SCV
-    instance SingI CW where
-      sing = SCW
-    instance SingI CX where
-      sing = SCX
-    instance SingI CY where
-      sing = SCY
-    instance SingI CZ where
-      sing = SCZ
-    instance (SingI n, SingI n) =>
-             SingI (Attr (n :: [AChar]) (n :: U)) where
-      sing = (SAttr sing) sing
-    instance SingI n => SingI1 (Attr (n :: [AChar])) where
-      liftSing = SAttr sing
-    instance SingI2 Attr where
-      liftSing2 = SAttr
-    instance SingI (AttrSym0 :: (~>) [AChar] ((~>) U Attribute)) where
-      sing = (singFun2 @AttrSym0) SAttr
-    instance SingI d =>
-             SingI (AttrSym1 (d :: [AChar]) :: (~>) U Attribute) where
-      sing = (singFun1 @(AttrSym1 (d :: [AChar]))) (SAttr (sing @d))
-    instance SingI1 (AttrSym1 :: [AChar] -> (~>) U Attribute) where
-      liftSing (s :: Sing (d :: [AChar]))
-        = (singFun1 @(AttrSym1 (d :: [AChar]))) (SAttr s)
-    instance SingI n => SingI (Sch (n :: [Attribute])) where
-      sing = SSch sing
-    instance SingI1 Sch where
-      liftSing = SSch
-    instance SingI (SchSym0 :: (~>) [Attribute] Schema) where
-      sing = (singFun1 @SchSym0) SSch
-GradingClient/Database.hs:0:0:: Splicing declarations
-    return [] ======>
-GradingClient/Database.hs:(0,0)-(0,0): Splicing expression
-    cases ''Row [| r |] [| changeId (n ++ (getId r)) r |]
-  ======>
-    case r of
-      EmptyRow _ -> (changeId (((++) n) (getId r))) r
-      ConsRow _ _ -> (changeId (((++) n) (getId r))) r
+    type instance Apply @Nat @Nat SuccSym0 a0123456789876543210 = Succ a0123456789876543210
+    instance SuppressUnusedWarnings SuccSym0 where
+      suppressUnusedWarnings = snd ((,) SuccSym0KindInference ())
+    type SuccSym1 :: Nat -> Nat
+    type family SuccSym1 (a0123456789876543210 :: Nat) :: Nat where
+      SuccSym1 a0123456789876543210 = Succ a0123456789876543210
+    type TFHelper_0123456789876543210 :: Nat -> Nat -> Bool
+    type family TFHelper_0123456789876543210 (a :: Nat) (a :: Nat) :: Bool where
+      TFHelper_0123456789876543210 Zero Zero = TrueSym0
+      TFHelper_0123456789876543210 Zero (Succ _) = FalseSym0
+      TFHelper_0123456789876543210 (Succ _) Zero = FalseSym0
+      TFHelper_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
+    instance PEq Nat where
+      type (==) a a = TFHelper_0123456789876543210 a a
+    type Compare_0123456789876543210 :: Nat -> Nat -> Ordering
+    type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where
+      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
+      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
+      Compare_0123456789876543210 Zero (Succ _) = LTSym0
+      Compare_0123456789876543210 (Succ _) Zero = GTSym0
+    instance POrd Nat where
+      type Compare a a = Compare_0123456789876543210 a a
+    data SNat :: Nat -> Type
+      where
+        SZero :: SNat (Zero :: Nat)
+        SSucc :: forall (n :: Nat). (Sing n) -> SNat (Succ n :: Nat)
+    type instance Sing @Nat = SNat
+    instance SingKind Nat where
+      type Demote Nat = Nat
+      fromSing SZero = Zero
+      fromSing (SSucc b) = Succ (fromSing b)
+      toSing Zero = SomeSing SZero
+      toSing (Succ (b :: Demote Nat))
+        = (\cases (SomeSing c) -> SomeSing (SSucc c))
+            (toSing b :: SomeSing Nat)
+    instance SEq Nat => SEq Nat where
+      (%==) SZero SZero = STrue
+      (%==) SZero (SSucc _) = SFalse
+      (%==) (SSucc _) SZero = SFalse
+      (%==)
+        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+            sB_0123456789876543210
+    instance SOrd Nat => SOrd Nat where
+      sCompare SZero SZero
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            SNil
+      sCompare
+        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               SNil)
+      sCompare SZero (SSucc _) = SLT
+      sCompare (SSucc _) SZero = SGT
+    instance SDecide Nat => SDecide Nat where
+      (%~) SZero SZero = Proved Refl
+      (%~) SZero (SSucc _) = Disproved (\case)
+      (%~) (SSucc _) SZero = Disproved (\case)
+      (%~) (SSucc a) (SSucc b)
+        = (\cases
+             (Proved Refl) -> Proved Refl
+             (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b)
+    instance Eq (SNat (z :: Nat)) where
+      (==) _ _ = True
+    instance SDecide Nat =>
+             GHC.Internal.Data.Type.Equality.TestEquality (SNat :: Nat
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
+        = Data.Singletons.Decide.decideEquality
+    instance SDecide Nat =>
+             GHC.Internal.Data.Type.Coercion.TestCoercion (SNat :: Nat
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
+        = Data.Singletons.Decide.decideCoercion
+    instance Ord (SNat (z :: Nat)) where
+      compare _ _ = EQ
+    instance SingI Zero where
+      sing = SZero
+    instance SingI n => SingI (Succ (n :: Nat)) where
+      sing = SSucc sing
+    instance SingI1 Succ where
+      liftSing = SSucc
+    instance SingI (SuccSym0 :: (~>) Nat Nat) where
+      sing = singFun1 @SuccSym0 SSucc
+GradingClient/Database.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| append :: Schema -> Schema -> Schema
+          append (Sch s1) (Sch s2) = Sch (s1 ++ s2)
+          attrNotIn :: Attribute -> Schema -> Bool
+          attrNotIn _ (Sch []) = True
+          attrNotIn (Attr name u) (Sch ((Attr name' _) : t))
+            = (name /= name') && (attrNotIn (Attr name u) (Sch t))
+          disjoint :: Schema -> Schema -> Bool
+          disjoint (Sch []) _ = True
+          disjoint (Sch (h : t)) s = (attrNotIn h s) && (disjoint (Sch t) s)
+          occurs :: [AChar] -> Schema -> Bool
+          occurs _ (Sch []) = False
+          occurs name (Sch ((Attr name' _) : attrs))
+            = name == name' || occurs name (Sch attrs)
+          lookup :: [AChar] -> Schema -> U
+          lookup _ (Sch []) = undefined
+          lookup name (Sch ((Attr name' u) : attrs))
+            = if name == name' then u else lookup name (Sch attrs)
+          
+          data U
+            = BOOL | STRING | NAT | VEC U Nat
+            deriving (Read, Eq, Show)
+          data AChar
+            = CA |
+              CB |
+              CC |
+              CD |
+              CE |
+              CF |
+              CG |
+              CH |
+              CI |
+              CJ |
+              CK |
+              CL |
+              CM |
+              CN |
+              CO |
+              CP |
+              CQ |
+              CR |
+              CS |
+              CT |
+              CU |
+              CV |
+              CW |
+              CX |
+              CY |
+              CZ
+            deriving (Read, Show, Eq)
+          data Attribute = Attr [AChar] U
+          data Schema = Sch [Attribute] |]
+  ======>
+    data U
+      = BOOL | STRING | NAT | VEC U Nat
+      deriving (Read, Eq, Show)
+    data AChar
+      = CA |
+        CB |
+        CC |
+        CD |
+        CE |
+        CF |
+        CG |
+        CH |
+        CI |
+        CJ |
+        CK |
+        CL |
+        CM |
+        CN |
+        CO |
+        CP |
+        CQ |
+        CR |
+        CS |
+        CT |
+        CU |
+        CV |
+        CW |
+        CX |
+        CY |
+        CZ
+      deriving (Read, Show, Eq)
+    data Attribute = Attr [AChar] U
+    data Schema = Sch [Attribute]
+    append :: Schema -> Schema -> Schema
+    append (Sch s1) (Sch s2) = Sch (s1 ++ s2)
+    attrNotIn :: Attribute -> Schema -> Bool
+    attrNotIn _ (Sch []) = True
+    attrNotIn (Attr name u) (Sch (Attr name' _ : t))
+      = ((name /= name') && attrNotIn (Attr name u) (Sch t))
+    disjoint :: Schema -> Schema -> Bool
+    disjoint (Sch []) _ = True
+    disjoint (Sch (h : t)) s = (attrNotIn h s && disjoint (Sch t) s)
+    occurs :: [AChar] -> Schema -> Bool
+    occurs _ (Sch []) = False
+    occurs name (Sch (Attr name' _ : attrs))
+      = ((name == name') || occurs name (Sch attrs))
+    lookup :: [AChar] -> Schema -> U
+    lookup _ (Sch []) = undefined
+    lookup name (Sch (Attr name' u : attrs))
+      = if (name == name') then u else lookup name (Sch attrs)
+    type BOOLSym0 :: U
+    type family BOOLSym0 :: U where
+      BOOLSym0 = BOOL
+    type STRINGSym0 :: U
+    type family STRINGSym0 :: U where
+      STRINGSym0 = STRING
+    type NATSym0 :: U
+    type family NATSym0 :: U where
+      NATSym0 = NAT
+    type VECSym0 :: (~>) U ((~>) Nat U)
+    data VECSym0 :: (~>) U ((~>) Nat U)
+      where
+        VECSym0KindInference :: SameKind (Apply VECSym0 arg) (VECSym1 arg) =>
+                                VECSym0 a0123456789876543210
+    type instance Apply @U @((~>) Nat U) VECSym0 a0123456789876543210 = VECSym1 a0123456789876543210
+    instance SuppressUnusedWarnings VECSym0 where
+      suppressUnusedWarnings = snd ((,) VECSym0KindInference ())
+    type VECSym1 :: U -> (~>) Nat U
+    data VECSym1 (a0123456789876543210 :: U) :: (~>) Nat U
+      where
+        VECSym1KindInference :: SameKind (Apply (VECSym1 a0123456789876543210) arg) (VECSym2 a0123456789876543210 arg) =>
+                                VECSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @U (VECSym1 a0123456789876543210) a0123456789876543210 = VEC a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (VECSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) VECSym1KindInference ())
+    type VECSym2 :: U -> Nat -> U
+    type family VECSym2 (a0123456789876543210 :: U) (a0123456789876543210 :: Nat) :: U where
+      VECSym2 a0123456789876543210 a0123456789876543210 = VEC a0123456789876543210 a0123456789876543210
+    type CASym0 :: AChar
+    type family CASym0 :: AChar where
+      CASym0 = CA
+    type CBSym0 :: AChar
+    type family CBSym0 :: AChar where
+      CBSym0 = CB
+    type CCSym0 :: AChar
+    type family CCSym0 :: AChar where
+      CCSym0 = CC
+    type CDSym0 :: AChar
+    type family CDSym0 :: AChar where
+      CDSym0 = CD
+    type CESym0 :: AChar
+    type family CESym0 :: AChar where
+      CESym0 = CE
+    type CFSym0 :: AChar
+    type family CFSym0 :: AChar where
+      CFSym0 = CF
+    type CGSym0 :: AChar
+    type family CGSym0 :: AChar where
+      CGSym0 = CG
+    type CHSym0 :: AChar
+    type family CHSym0 :: AChar where
+      CHSym0 = CH
+    type CISym0 :: AChar
+    type family CISym0 :: AChar where
+      CISym0 = CI
+    type CJSym0 :: AChar
+    type family CJSym0 :: AChar where
+      CJSym0 = CJ
+    type CKSym0 :: AChar
+    type family CKSym0 :: AChar where
+      CKSym0 = CK
+    type CLSym0 :: AChar
+    type family CLSym0 :: AChar where
+      CLSym0 = CL
+    type CMSym0 :: AChar
+    type family CMSym0 :: AChar where
+      CMSym0 = CM
+    type CNSym0 :: AChar
+    type family CNSym0 :: AChar where
+      CNSym0 = CN
+    type COSym0 :: AChar
+    type family COSym0 :: AChar where
+      COSym0 = CO
+    type CPSym0 :: AChar
+    type family CPSym0 :: AChar where
+      CPSym0 = CP
+    type CQSym0 :: AChar
+    type family CQSym0 :: AChar where
+      CQSym0 = CQ
+    type CRSym0 :: AChar
+    type family CRSym0 :: AChar where
+      CRSym0 = CR
+    type CSSym0 :: AChar
+    type family CSSym0 :: AChar where
+      CSSym0 = CS
+    type CTSym0 :: AChar
+    type family CTSym0 :: AChar where
+      CTSym0 = CT
+    type CUSym0 :: AChar
+    type family CUSym0 :: AChar where
+      CUSym0 = CU
+    type CVSym0 :: AChar
+    type family CVSym0 :: AChar where
+      CVSym0 = CV
+    type CWSym0 :: AChar
+    type family CWSym0 :: AChar where
+      CWSym0 = CW
+    type CXSym0 :: AChar
+    type family CXSym0 :: AChar where
+      CXSym0 = CX
+    type CYSym0 :: AChar
+    type family CYSym0 :: AChar where
+      CYSym0 = CY
+    type CZSym0 :: AChar
+    type family CZSym0 :: AChar where
+      CZSym0 = CZ
+    type AttrSym0 :: (~>) [AChar] ((~>) U Attribute)
+    data AttrSym0 :: (~>) [AChar] ((~>) U Attribute)
+      where
+        AttrSym0KindInference :: SameKind (Apply AttrSym0 arg) (AttrSym1 arg) =>
+                                 AttrSym0 a0123456789876543210
+    type instance Apply @[AChar] @((~>) U Attribute) AttrSym0 a0123456789876543210 = AttrSym1 a0123456789876543210
+    instance SuppressUnusedWarnings AttrSym0 where
+      suppressUnusedWarnings = snd ((,) AttrSym0KindInference ())
+    type AttrSym1 :: [AChar] -> (~>) U Attribute
+    data AttrSym1 (a0123456789876543210 :: [AChar]) :: (~>) U Attribute
+      where
+        AttrSym1KindInference :: SameKind (Apply (AttrSym1 a0123456789876543210) arg) (AttrSym2 a0123456789876543210 arg) =>
+                                 AttrSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @U @Attribute (AttrSym1 a0123456789876543210) a0123456789876543210 = Attr a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (AttrSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) AttrSym1KindInference ())
+    type AttrSym2 :: [AChar] -> U -> Attribute
+    type family AttrSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: U) :: Attribute where
+      AttrSym2 a0123456789876543210 a0123456789876543210 = Attr a0123456789876543210 a0123456789876543210
+    type SchSym0 :: (~>) [Attribute] Schema
+    data SchSym0 :: (~>) [Attribute] Schema
+      where
+        SchSym0KindInference :: SameKind (Apply SchSym0 arg) (SchSym1 arg) =>
+                                SchSym0 a0123456789876543210
+    type instance Apply @[Attribute] @Schema SchSym0 a0123456789876543210 = Sch a0123456789876543210
+    instance SuppressUnusedWarnings SchSym0 where
+      suppressUnusedWarnings = snd ((,) SchSym0KindInference ())
+    type SchSym1 :: [Attribute] -> Schema
+    type family SchSym1 (a0123456789876543210 :: [Attribute]) :: Schema where
+      SchSym1 a0123456789876543210 = Sch a0123456789876543210
+    type family LamCases_0123456789876543210 (name0123456789876543210 :: [AChar]) name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 name name' u attrs 'True = u
+      LamCases_0123456789876543210 name name' u attrs 'False = Apply (Apply LookupSym0 name) (Apply SchSym0 attrs)
+    data LamCases_0123456789876543210Sym0 (name0123456789876543210 :: [AChar]) name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210) arg) (LamCases_0123456789876543210Sym1 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (name0123456789876543210 :: [AChar]) name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 a_01234567898765432100123456789876543210
+    type LookupSym0 :: (~>) [AChar] ((~>) Schema U)
+    data LookupSym0 :: (~>) [AChar] ((~>) Schema U)
+      where
+        LookupSym0KindInference :: SameKind (Apply LookupSym0 arg) (LookupSym1 arg) =>
+                                   LookupSym0 a0123456789876543210
+    type instance Apply @[AChar] @((~>) Schema U) LookupSym0 a0123456789876543210 = LookupSym1 a0123456789876543210
+    instance SuppressUnusedWarnings LookupSym0 where
+      suppressUnusedWarnings = snd ((,) LookupSym0KindInference ())
+    type LookupSym1 :: [AChar] -> (~>) Schema U
+    data LookupSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema U
+      where
+        LookupSym1KindInference :: SameKind (Apply (LookupSym1 a0123456789876543210) arg) (LookupSym2 a0123456789876543210 arg) =>
+                                   LookupSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @Schema @U (LookupSym1 a0123456789876543210) a0123456789876543210 = Lookup a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (LookupSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) LookupSym1KindInference ())
+    type LookupSym2 :: [AChar] -> Schema -> U
+    type family LookupSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) :: U where
+      LookupSym2 a0123456789876543210 a0123456789876543210 = Lookup a0123456789876543210 a0123456789876543210
+    type OccursSym0 :: (~>) [AChar] ((~>) Schema Bool)
+    data OccursSym0 :: (~>) [AChar] ((~>) Schema Bool)
+      where
+        OccursSym0KindInference :: SameKind (Apply OccursSym0 arg) (OccursSym1 arg) =>
+                                   OccursSym0 a0123456789876543210
+    type instance Apply @[AChar] @((~>) Schema Bool) OccursSym0 a0123456789876543210 = OccursSym1 a0123456789876543210
+    instance SuppressUnusedWarnings OccursSym0 where
+      suppressUnusedWarnings = snd ((,) OccursSym0KindInference ())
+    type OccursSym1 :: [AChar] -> (~>) Schema Bool
+    data OccursSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema Bool
+      where
+        OccursSym1KindInference :: SameKind (Apply (OccursSym1 a0123456789876543210) arg) (OccursSym2 a0123456789876543210 arg) =>
+                                   OccursSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @Schema @Bool (OccursSym1 a0123456789876543210) a0123456789876543210 = Occurs a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (OccursSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) OccursSym1KindInference ())
+    type OccursSym2 :: [AChar] -> Schema -> Bool
+    type family OccursSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) :: Bool where
+      OccursSym2 a0123456789876543210 a0123456789876543210 = Occurs a0123456789876543210 a0123456789876543210
+    type DisjointSym0 :: (~>) Schema ((~>) Schema Bool)
+    data DisjointSym0 :: (~>) Schema ((~>) Schema Bool)
+      where
+        DisjointSym0KindInference :: SameKind (Apply DisjointSym0 arg) (DisjointSym1 arg) =>
+                                     DisjointSym0 a0123456789876543210
+    type instance Apply @Schema @((~>) Schema Bool) DisjointSym0 a0123456789876543210 = DisjointSym1 a0123456789876543210
+    instance SuppressUnusedWarnings DisjointSym0 where
+      suppressUnusedWarnings = snd ((,) DisjointSym0KindInference ())
+    type DisjointSym1 :: Schema -> (~>) Schema Bool
+    data DisjointSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Bool
+      where
+        DisjointSym1KindInference :: SameKind (Apply (DisjointSym1 a0123456789876543210) arg) (DisjointSym2 a0123456789876543210 arg) =>
+                                     DisjointSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @Schema @Bool (DisjointSym1 a0123456789876543210) a0123456789876543210 = Disjoint a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (DisjointSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) DisjointSym1KindInference ())
+    type DisjointSym2 :: Schema -> Schema -> Bool
+    type family DisjointSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) :: Bool where
+      DisjointSym2 a0123456789876543210 a0123456789876543210 = Disjoint a0123456789876543210 a0123456789876543210
+    type AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool)
+    data AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool)
+      where
+        AttrNotInSym0KindInference :: SameKind (Apply AttrNotInSym0 arg) (AttrNotInSym1 arg) =>
+                                      AttrNotInSym0 a0123456789876543210
+    type instance Apply @Attribute @((~>) Schema Bool) AttrNotInSym0 a0123456789876543210 = AttrNotInSym1 a0123456789876543210
+    instance SuppressUnusedWarnings AttrNotInSym0 where
+      suppressUnusedWarnings = snd ((,) AttrNotInSym0KindInference ())
+    type AttrNotInSym1 :: Attribute -> (~>) Schema Bool
+    data AttrNotInSym1 (a0123456789876543210 :: Attribute) :: (~>) Schema Bool
+      where
+        AttrNotInSym1KindInference :: SameKind (Apply (AttrNotInSym1 a0123456789876543210) arg) (AttrNotInSym2 a0123456789876543210 arg) =>
+                                      AttrNotInSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @Schema @Bool (AttrNotInSym1 a0123456789876543210) a0123456789876543210 = AttrNotIn a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (AttrNotInSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) AttrNotInSym1KindInference ())
+    type AttrNotInSym2 :: Attribute -> Schema -> Bool
+    type family AttrNotInSym2 (a0123456789876543210 :: Attribute) (a0123456789876543210 :: Schema) :: Bool where
+      AttrNotInSym2 a0123456789876543210 a0123456789876543210 = AttrNotIn a0123456789876543210 a0123456789876543210
+    type AppendSym0 :: (~>) Schema ((~>) Schema Schema)
+    data AppendSym0 :: (~>) Schema ((~>) Schema Schema)
+      where
+        AppendSym0KindInference :: SameKind (Apply AppendSym0 arg) (AppendSym1 arg) =>
+                                   AppendSym0 a0123456789876543210
+    type instance Apply @Schema @((~>) Schema Schema) AppendSym0 a0123456789876543210 = AppendSym1 a0123456789876543210
+    instance SuppressUnusedWarnings AppendSym0 where
+      suppressUnusedWarnings = snd ((,) AppendSym0KindInference ())
+    type AppendSym1 :: Schema -> (~>) Schema Schema
+    data AppendSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Schema
+      where
+        AppendSym1KindInference :: SameKind (Apply (AppendSym1 a0123456789876543210) arg) (AppendSym2 a0123456789876543210 arg) =>
+                                   AppendSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @Schema @Schema (AppendSym1 a0123456789876543210) a0123456789876543210 = Append a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (AppendSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) AppendSym1KindInference ())
+    type AppendSym2 :: Schema -> Schema -> Schema
+    type family AppendSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) :: Schema where
+      AppendSym2 a0123456789876543210 a0123456789876543210 = Append a0123456789876543210 a0123456789876543210
+    type Lookup :: [AChar] -> Schema -> U
+    type family Lookup (a :: [AChar]) (a :: Schema) :: U where
+      Lookup _ (Sch '[]) = UndefinedSym0
+      Lookup name (Sch ('(:) (Attr name' u) attrs)) = Apply (LamCases_0123456789876543210Sym0 name name' u attrs) (Apply (Apply (==@#@$) name) name')
+    type Occurs :: [AChar] -> Schema -> Bool
+    type family Occurs (a :: [AChar]) (a :: Schema) :: Bool where
+      Occurs _ (Sch '[]) = FalseSym0
+      Occurs name (Sch ('(:) (Attr name' _) attrs)) = Apply (Apply (||@#@$) (Apply (Apply (==@#@$) name) name')) (Apply (Apply OccursSym0 name) (Apply SchSym0 attrs))
+    type Disjoint :: Schema -> Schema -> Bool
+    type family Disjoint (a :: Schema) (a :: Schema) :: Bool where
+      Disjoint (Sch '[]) _ = TrueSym0
+      Disjoint (Sch ('(:) h t)) s = Apply (Apply (&&@#@$) (Apply (Apply AttrNotInSym0 h) s)) (Apply (Apply DisjointSym0 (Apply SchSym0 t)) s)
+    type AttrNotIn :: Attribute -> Schema -> Bool
+    type family AttrNotIn (a :: Attribute) (a :: Schema) :: Bool where
+      AttrNotIn _ (Sch '[]) = TrueSym0
+      AttrNotIn (Attr name u) (Sch ('(:) (Attr name' _) t)) = Apply (Apply (&&@#@$) (Apply (Apply (/=@#@$) name) name')) (Apply (Apply AttrNotInSym0 (Apply (Apply AttrSym0 name) u)) (Apply SchSym0 t))
+    type Append :: Schema -> Schema -> Schema
+    type family Append (a :: Schema) (a :: Schema) :: Schema where
+      Append (Sch s1) (Sch s2) = Apply SchSym0 (Apply (Apply (++@#@$) s1) s2)
+    type TFHelper_0123456789876543210 :: U -> U -> Bool
+    type family TFHelper_0123456789876543210 (a :: U) (a :: U) :: Bool where
+      TFHelper_0123456789876543210 BOOL BOOL = TrueSym0
+      TFHelper_0123456789876543210 BOOL STRING = FalseSym0
+      TFHelper_0123456789876543210 BOOL NAT = FalseSym0
+      TFHelper_0123456789876543210 BOOL (VEC _ _) = FalseSym0
+      TFHelper_0123456789876543210 STRING BOOL = FalseSym0
+      TFHelper_0123456789876543210 STRING STRING = TrueSym0
+      TFHelper_0123456789876543210 STRING NAT = FalseSym0
+      TFHelper_0123456789876543210 STRING (VEC _ _) = FalseSym0
+      TFHelper_0123456789876543210 NAT BOOL = FalseSym0
+      TFHelper_0123456789876543210 NAT STRING = FalseSym0
+      TFHelper_0123456789876543210 NAT NAT = TrueSym0
+      TFHelper_0123456789876543210 NAT (VEC _ _) = FalseSym0
+      TFHelper_0123456789876543210 (VEC _ _) BOOL = FalseSym0
+      TFHelper_0123456789876543210 (VEC _ _) STRING = FalseSym0
+      TFHelper_0123456789876543210 (VEC _ _) NAT = FalseSym0
+      TFHelper_0123456789876543210 (VEC a_0123456789876543210 a_0123456789876543210) (VEC b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)
+    instance PEq U where
+      type (==) a a = TFHelper_0123456789876543210 a a
+    type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                          -> U -> Symbol -> Symbol
+    type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: U) (a :: Symbol) :: Symbol where
+      ShowsPrec_0123456789876543210 _ BOOL a_0123456789876543210 = Apply (Apply ShowStringSym0 "BOOL") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ STRING a_0123456789876543210 = Apply (Apply ShowStringSym0 "STRING") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ NAT a_0123456789876543210 = Apply (Apply ShowStringSym0 "NAT") a_0123456789876543210
+      ShowsPrec_0123456789876543210 p_0123456789876543210 (VEC arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "VEC ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210
+    instance PShow U where
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
+    type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                          -> AChar -> Symbol -> Symbol
+    type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: AChar) (a :: Symbol) :: Symbol where
+      ShowsPrec_0123456789876543210 _ CA a_0123456789876543210 = Apply (Apply ShowStringSym0 "CA") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CB a_0123456789876543210 = Apply (Apply ShowStringSym0 "CB") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CC a_0123456789876543210 = Apply (Apply ShowStringSym0 "CC") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CD a_0123456789876543210 = Apply (Apply ShowStringSym0 "CD") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CE a_0123456789876543210 = Apply (Apply ShowStringSym0 "CE") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CF a_0123456789876543210 = Apply (Apply ShowStringSym0 "CF") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CG a_0123456789876543210 = Apply (Apply ShowStringSym0 "CG") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CH a_0123456789876543210 = Apply (Apply ShowStringSym0 "CH") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CI a_0123456789876543210 = Apply (Apply ShowStringSym0 "CI") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CJ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CJ") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CK a_0123456789876543210 = Apply (Apply ShowStringSym0 "CK") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CL a_0123456789876543210 = Apply (Apply ShowStringSym0 "CL") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CM a_0123456789876543210 = Apply (Apply ShowStringSym0 "CM") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CN a_0123456789876543210 = Apply (Apply ShowStringSym0 "CN") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CO a_0123456789876543210 = Apply (Apply ShowStringSym0 "CO") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CP a_0123456789876543210 = Apply (Apply ShowStringSym0 "CP") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CQ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CQ") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CR a_0123456789876543210 = Apply (Apply ShowStringSym0 "CR") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CS a_0123456789876543210 = Apply (Apply ShowStringSym0 "CS") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CT a_0123456789876543210 = Apply (Apply ShowStringSym0 "CT") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CU a_0123456789876543210 = Apply (Apply ShowStringSym0 "CU") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CV a_0123456789876543210 = Apply (Apply ShowStringSym0 "CV") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CW a_0123456789876543210 = Apply (Apply ShowStringSym0 "CW") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CX a_0123456789876543210 = Apply (Apply ShowStringSym0 "CX") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CY a_0123456789876543210 = Apply (Apply ShowStringSym0 "CY") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ CZ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CZ") a_0123456789876543210
+    instance PShow AChar where
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
+    type TFHelper_0123456789876543210 :: AChar -> AChar -> Bool
+    type family TFHelper_0123456789876543210 (a :: AChar) (a :: AChar) :: Bool where
+      TFHelper_0123456789876543210 CA CA = TrueSym0
+      TFHelper_0123456789876543210 CA CB = FalseSym0
+      TFHelper_0123456789876543210 CA CC = FalseSym0
+      TFHelper_0123456789876543210 CA CD = FalseSym0
+      TFHelper_0123456789876543210 CA CE = FalseSym0
+      TFHelper_0123456789876543210 CA CF = FalseSym0
+      TFHelper_0123456789876543210 CA CG = FalseSym0
+      TFHelper_0123456789876543210 CA CH = FalseSym0
+      TFHelper_0123456789876543210 CA CI = FalseSym0
+      TFHelper_0123456789876543210 CA CJ = FalseSym0
+      TFHelper_0123456789876543210 CA CK = FalseSym0
+      TFHelper_0123456789876543210 CA CL = FalseSym0
+      TFHelper_0123456789876543210 CA CM = FalseSym0
+      TFHelper_0123456789876543210 CA CN = FalseSym0
+      TFHelper_0123456789876543210 CA CO = FalseSym0
+      TFHelper_0123456789876543210 CA CP = FalseSym0
+      TFHelper_0123456789876543210 CA CQ = FalseSym0
+      TFHelper_0123456789876543210 CA CR = FalseSym0
+      TFHelper_0123456789876543210 CA CS = FalseSym0
+      TFHelper_0123456789876543210 CA CT = FalseSym0
+      TFHelper_0123456789876543210 CA CU = FalseSym0
+      TFHelper_0123456789876543210 CA CV = FalseSym0
+      TFHelper_0123456789876543210 CA CW = FalseSym0
+      TFHelper_0123456789876543210 CA CX = FalseSym0
+      TFHelper_0123456789876543210 CA CY = FalseSym0
+      TFHelper_0123456789876543210 CA CZ = FalseSym0
+      TFHelper_0123456789876543210 CB CA = FalseSym0
+      TFHelper_0123456789876543210 CB CB = TrueSym0
+      TFHelper_0123456789876543210 CB CC = FalseSym0
+      TFHelper_0123456789876543210 CB CD = FalseSym0
+      TFHelper_0123456789876543210 CB CE = FalseSym0
+      TFHelper_0123456789876543210 CB CF = FalseSym0
+      TFHelper_0123456789876543210 CB CG = FalseSym0
+      TFHelper_0123456789876543210 CB CH = FalseSym0
+      TFHelper_0123456789876543210 CB CI = FalseSym0
+      TFHelper_0123456789876543210 CB CJ = FalseSym0
+      TFHelper_0123456789876543210 CB CK = FalseSym0
+      TFHelper_0123456789876543210 CB CL = FalseSym0
+      TFHelper_0123456789876543210 CB CM = FalseSym0
+      TFHelper_0123456789876543210 CB CN = FalseSym0
+      TFHelper_0123456789876543210 CB CO = FalseSym0
+      TFHelper_0123456789876543210 CB CP = FalseSym0
+      TFHelper_0123456789876543210 CB CQ = FalseSym0
+      TFHelper_0123456789876543210 CB CR = FalseSym0
+      TFHelper_0123456789876543210 CB CS = FalseSym0
+      TFHelper_0123456789876543210 CB CT = FalseSym0
+      TFHelper_0123456789876543210 CB CU = FalseSym0
+      TFHelper_0123456789876543210 CB CV = FalseSym0
+      TFHelper_0123456789876543210 CB CW = FalseSym0
+      TFHelper_0123456789876543210 CB CX = FalseSym0
+      TFHelper_0123456789876543210 CB CY = FalseSym0
+      TFHelper_0123456789876543210 CB CZ = FalseSym0
+      TFHelper_0123456789876543210 CC CA = FalseSym0
+      TFHelper_0123456789876543210 CC CB = FalseSym0
+      TFHelper_0123456789876543210 CC CC = TrueSym0
+      TFHelper_0123456789876543210 CC CD = FalseSym0
+      TFHelper_0123456789876543210 CC CE = FalseSym0
+      TFHelper_0123456789876543210 CC CF = FalseSym0
+      TFHelper_0123456789876543210 CC CG = FalseSym0
+      TFHelper_0123456789876543210 CC CH = FalseSym0
+      TFHelper_0123456789876543210 CC CI = FalseSym0
+      TFHelper_0123456789876543210 CC CJ = FalseSym0
+      TFHelper_0123456789876543210 CC CK = FalseSym0
+      TFHelper_0123456789876543210 CC CL = FalseSym0
+      TFHelper_0123456789876543210 CC CM = FalseSym0
+      TFHelper_0123456789876543210 CC CN = FalseSym0
+      TFHelper_0123456789876543210 CC CO = FalseSym0
+      TFHelper_0123456789876543210 CC CP = FalseSym0
+      TFHelper_0123456789876543210 CC CQ = FalseSym0
+      TFHelper_0123456789876543210 CC CR = FalseSym0
+      TFHelper_0123456789876543210 CC CS = FalseSym0
+      TFHelper_0123456789876543210 CC CT = FalseSym0
+      TFHelper_0123456789876543210 CC CU = FalseSym0
+      TFHelper_0123456789876543210 CC CV = FalseSym0
+      TFHelper_0123456789876543210 CC CW = FalseSym0
+      TFHelper_0123456789876543210 CC CX = FalseSym0
+      TFHelper_0123456789876543210 CC CY = FalseSym0
+      TFHelper_0123456789876543210 CC CZ = FalseSym0
+      TFHelper_0123456789876543210 CD CA = FalseSym0
+      TFHelper_0123456789876543210 CD CB = FalseSym0
+      TFHelper_0123456789876543210 CD CC = FalseSym0
+      TFHelper_0123456789876543210 CD CD = TrueSym0
+      TFHelper_0123456789876543210 CD CE = FalseSym0
+      TFHelper_0123456789876543210 CD CF = FalseSym0
+      TFHelper_0123456789876543210 CD CG = FalseSym0
+      TFHelper_0123456789876543210 CD CH = FalseSym0
+      TFHelper_0123456789876543210 CD CI = FalseSym0
+      TFHelper_0123456789876543210 CD CJ = FalseSym0
+      TFHelper_0123456789876543210 CD CK = FalseSym0
+      TFHelper_0123456789876543210 CD CL = FalseSym0
+      TFHelper_0123456789876543210 CD CM = FalseSym0
+      TFHelper_0123456789876543210 CD CN = FalseSym0
+      TFHelper_0123456789876543210 CD CO = FalseSym0
+      TFHelper_0123456789876543210 CD CP = FalseSym0
+      TFHelper_0123456789876543210 CD CQ = FalseSym0
+      TFHelper_0123456789876543210 CD CR = FalseSym0
+      TFHelper_0123456789876543210 CD CS = FalseSym0
+      TFHelper_0123456789876543210 CD CT = FalseSym0
+      TFHelper_0123456789876543210 CD CU = FalseSym0
+      TFHelper_0123456789876543210 CD CV = FalseSym0
+      TFHelper_0123456789876543210 CD CW = FalseSym0
+      TFHelper_0123456789876543210 CD CX = FalseSym0
+      TFHelper_0123456789876543210 CD CY = FalseSym0
+      TFHelper_0123456789876543210 CD CZ = FalseSym0
+      TFHelper_0123456789876543210 CE CA = FalseSym0
+      TFHelper_0123456789876543210 CE CB = FalseSym0
+      TFHelper_0123456789876543210 CE CC = FalseSym0
+      TFHelper_0123456789876543210 CE CD = FalseSym0
+      TFHelper_0123456789876543210 CE CE = TrueSym0
+      TFHelper_0123456789876543210 CE CF = FalseSym0
+      TFHelper_0123456789876543210 CE CG = FalseSym0
+      TFHelper_0123456789876543210 CE CH = FalseSym0
+      TFHelper_0123456789876543210 CE CI = FalseSym0
+      TFHelper_0123456789876543210 CE CJ = FalseSym0
+      TFHelper_0123456789876543210 CE CK = FalseSym0
+      TFHelper_0123456789876543210 CE CL = FalseSym0
+      TFHelper_0123456789876543210 CE CM = FalseSym0
+      TFHelper_0123456789876543210 CE CN = FalseSym0
+      TFHelper_0123456789876543210 CE CO = FalseSym0
+      TFHelper_0123456789876543210 CE CP = FalseSym0
+      TFHelper_0123456789876543210 CE CQ = FalseSym0
+      TFHelper_0123456789876543210 CE CR = FalseSym0
+      TFHelper_0123456789876543210 CE CS = FalseSym0
+      TFHelper_0123456789876543210 CE CT = FalseSym0
+      TFHelper_0123456789876543210 CE CU = FalseSym0
+      TFHelper_0123456789876543210 CE CV = FalseSym0
+      TFHelper_0123456789876543210 CE CW = FalseSym0
+      TFHelper_0123456789876543210 CE CX = FalseSym0
+      TFHelper_0123456789876543210 CE CY = FalseSym0
+      TFHelper_0123456789876543210 CE CZ = FalseSym0
+      TFHelper_0123456789876543210 CF CA = FalseSym0
+      TFHelper_0123456789876543210 CF CB = FalseSym0
+      TFHelper_0123456789876543210 CF CC = FalseSym0
+      TFHelper_0123456789876543210 CF CD = FalseSym0
+      TFHelper_0123456789876543210 CF CE = FalseSym0
+      TFHelper_0123456789876543210 CF CF = TrueSym0
+      TFHelper_0123456789876543210 CF CG = FalseSym0
+      TFHelper_0123456789876543210 CF CH = FalseSym0
+      TFHelper_0123456789876543210 CF CI = FalseSym0
+      TFHelper_0123456789876543210 CF CJ = FalseSym0
+      TFHelper_0123456789876543210 CF CK = FalseSym0
+      TFHelper_0123456789876543210 CF CL = FalseSym0
+      TFHelper_0123456789876543210 CF CM = FalseSym0
+      TFHelper_0123456789876543210 CF CN = FalseSym0
+      TFHelper_0123456789876543210 CF CO = FalseSym0
+      TFHelper_0123456789876543210 CF CP = FalseSym0
+      TFHelper_0123456789876543210 CF CQ = FalseSym0
+      TFHelper_0123456789876543210 CF CR = FalseSym0
+      TFHelper_0123456789876543210 CF CS = FalseSym0
+      TFHelper_0123456789876543210 CF CT = FalseSym0
+      TFHelper_0123456789876543210 CF CU = FalseSym0
+      TFHelper_0123456789876543210 CF CV = FalseSym0
+      TFHelper_0123456789876543210 CF CW = FalseSym0
+      TFHelper_0123456789876543210 CF CX = FalseSym0
+      TFHelper_0123456789876543210 CF CY = FalseSym0
+      TFHelper_0123456789876543210 CF CZ = FalseSym0
+      TFHelper_0123456789876543210 CG CA = FalseSym0
+      TFHelper_0123456789876543210 CG CB = FalseSym0
+      TFHelper_0123456789876543210 CG CC = FalseSym0
+      TFHelper_0123456789876543210 CG CD = FalseSym0
+      TFHelper_0123456789876543210 CG CE = FalseSym0
+      TFHelper_0123456789876543210 CG CF = FalseSym0
+      TFHelper_0123456789876543210 CG CG = TrueSym0
+      TFHelper_0123456789876543210 CG CH = FalseSym0
+      TFHelper_0123456789876543210 CG CI = FalseSym0
+      TFHelper_0123456789876543210 CG CJ = FalseSym0
+      TFHelper_0123456789876543210 CG CK = FalseSym0
+      TFHelper_0123456789876543210 CG CL = FalseSym0
+      TFHelper_0123456789876543210 CG CM = FalseSym0
+      TFHelper_0123456789876543210 CG CN = FalseSym0
+      TFHelper_0123456789876543210 CG CO = FalseSym0
+      TFHelper_0123456789876543210 CG CP = FalseSym0
+      TFHelper_0123456789876543210 CG CQ = FalseSym0
+      TFHelper_0123456789876543210 CG CR = FalseSym0
+      TFHelper_0123456789876543210 CG CS = FalseSym0
+      TFHelper_0123456789876543210 CG CT = FalseSym0
+      TFHelper_0123456789876543210 CG CU = FalseSym0
+      TFHelper_0123456789876543210 CG CV = FalseSym0
+      TFHelper_0123456789876543210 CG CW = FalseSym0
+      TFHelper_0123456789876543210 CG CX = FalseSym0
+      TFHelper_0123456789876543210 CG CY = FalseSym0
+      TFHelper_0123456789876543210 CG CZ = FalseSym0
+      TFHelper_0123456789876543210 CH CA = FalseSym0
+      TFHelper_0123456789876543210 CH CB = FalseSym0
+      TFHelper_0123456789876543210 CH CC = FalseSym0
+      TFHelper_0123456789876543210 CH CD = FalseSym0
+      TFHelper_0123456789876543210 CH CE = FalseSym0
+      TFHelper_0123456789876543210 CH CF = FalseSym0
+      TFHelper_0123456789876543210 CH CG = FalseSym0
+      TFHelper_0123456789876543210 CH CH = TrueSym0
+      TFHelper_0123456789876543210 CH CI = FalseSym0
+      TFHelper_0123456789876543210 CH CJ = FalseSym0
+      TFHelper_0123456789876543210 CH CK = FalseSym0
+      TFHelper_0123456789876543210 CH CL = FalseSym0
+      TFHelper_0123456789876543210 CH CM = FalseSym0
+      TFHelper_0123456789876543210 CH CN = FalseSym0
+      TFHelper_0123456789876543210 CH CO = FalseSym0
+      TFHelper_0123456789876543210 CH CP = FalseSym0
+      TFHelper_0123456789876543210 CH CQ = FalseSym0
+      TFHelper_0123456789876543210 CH CR = FalseSym0
+      TFHelper_0123456789876543210 CH CS = FalseSym0
+      TFHelper_0123456789876543210 CH CT = FalseSym0
+      TFHelper_0123456789876543210 CH CU = FalseSym0
+      TFHelper_0123456789876543210 CH CV = FalseSym0
+      TFHelper_0123456789876543210 CH CW = FalseSym0
+      TFHelper_0123456789876543210 CH CX = FalseSym0
+      TFHelper_0123456789876543210 CH CY = FalseSym0
+      TFHelper_0123456789876543210 CH CZ = FalseSym0
+      TFHelper_0123456789876543210 CI CA = FalseSym0
+      TFHelper_0123456789876543210 CI CB = FalseSym0
+      TFHelper_0123456789876543210 CI CC = FalseSym0
+      TFHelper_0123456789876543210 CI CD = FalseSym0
+      TFHelper_0123456789876543210 CI CE = FalseSym0
+      TFHelper_0123456789876543210 CI CF = FalseSym0
+      TFHelper_0123456789876543210 CI CG = FalseSym0
+      TFHelper_0123456789876543210 CI CH = FalseSym0
+      TFHelper_0123456789876543210 CI CI = TrueSym0
+      TFHelper_0123456789876543210 CI CJ = FalseSym0
+      TFHelper_0123456789876543210 CI CK = FalseSym0
+      TFHelper_0123456789876543210 CI CL = FalseSym0
+      TFHelper_0123456789876543210 CI CM = FalseSym0
+      TFHelper_0123456789876543210 CI CN = FalseSym0
+      TFHelper_0123456789876543210 CI CO = FalseSym0
+      TFHelper_0123456789876543210 CI CP = FalseSym0
+      TFHelper_0123456789876543210 CI CQ = FalseSym0
+      TFHelper_0123456789876543210 CI CR = FalseSym0
+      TFHelper_0123456789876543210 CI CS = FalseSym0
+      TFHelper_0123456789876543210 CI CT = FalseSym0
+      TFHelper_0123456789876543210 CI CU = FalseSym0
+      TFHelper_0123456789876543210 CI CV = FalseSym0
+      TFHelper_0123456789876543210 CI CW = FalseSym0
+      TFHelper_0123456789876543210 CI CX = FalseSym0
+      TFHelper_0123456789876543210 CI CY = FalseSym0
+      TFHelper_0123456789876543210 CI CZ = FalseSym0
+      TFHelper_0123456789876543210 CJ CA = FalseSym0
+      TFHelper_0123456789876543210 CJ CB = FalseSym0
+      TFHelper_0123456789876543210 CJ CC = FalseSym0
+      TFHelper_0123456789876543210 CJ CD = FalseSym0
+      TFHelper_0123456789876543210 CJ CE = FalseSym0
+      TFHelper_0123456789876543210 CJ CF = FalseSym0
+      TFHelper_0123456789876543210 CJ CG = FalseSym0
+      TFHelper_0123456789876543210 CJ CH = FalseSym0
+      TFHelper_0123456789876543210 CJ CI = FalseSym0
+      TFHelper_0123456789876543210 CJ CJ = TrueSym0
+      TFHelper_0123456789876543210 CJ CK = FalseSym0
+      TFHelper_0123456789876543210 CJ CL = FalseSym0
+      TFHelper_0123456789876543210 CJ CM = FalseSym0
+      TFHelper_0123456789876543210 CJ CN = FalseSym0
+      TFHelper_0123456789876543210 CJ CO = FalseSym0
+      TFHelper_0123456789876543210 CJ CP = FalseSym0
+      TFHelper_0123456789876543210 CJ CQ = FalseSym0
+      TFHelper_0123456789876543210 CJ CR = FalseSym0
+      TFHelper_0123456789876543210 CJ CS = FalseSym0
+      TFHelper_0123456789876543210 CJ CT = FalseSym0
+      TFHelper_0123456789876543210 CJ CU = FalseSym0
+      TFHelper_0123456789876543210 CJ CV = FalseSym0
+      TFHelper_0123456789876543210 CJ CW = FalseSym0
+      TFHelper_0123456789876543210 CJ CX = FalseSym0
+      TFHelper_0123456789876543210 CJ CY = FalseSym0
+      TFHelper_0123456789876543210 CJ CZ = FalseSym0
+      TFHelper_0123456789876543210 CK CA = FalseSym0
+      TFHelper_0123456789876543210 CK CB = FalseSym0
+      TFHelper_0123456789876543210 CK CC = FalseSym0
+      TFHelper_0123456789876543210 CK CD = FalseSym0
+      TFHelper_0123456789876543210 CK CE = FalseSym0
+      TFHelper_0123456789876543210 CK CF = FalseSym0
+      TFHelper_0123456789876543210 CK CG = FalseSym0
+      TFHelper_0123456789876543210 CK CH = FalseSym0
+      TFHelper_0123456789876543210 CK CI = FalseSym0
+      TFHelper_0123456789876543210 CK CJ = FalseSym0
+      TFHelper_0123456789876543210 CK CK = TrueSym0
+      TFHelper_0123456789876543210 CK CL = FalseSym0
+      TFHelper_0123456789876543210 CK CM = FalseSym0
+      TFHelper_0123456789876543210 CK CN = FalseSym0
+      TFHelper_0123456789876543210 CK CO = FalseSym0
+      TFHelper_0123456789876543210 CK CP = FalseSym0
+      TFHelper_0123456789876543210 CK CQ = FalseSym0
+      TFHelper_0123456789876543210 CK CR = FalseSym0
+      TFHelper_0123456789876543210 CK CS = FalseSym0
+      TFHelper_0123456789876543210 CK CT = FalseSym0
+      TFHelper_0123456789876543210 CK CU = FalseSym0
+      TFHelper_0123456789876543210 CK CV = FalseSym0
+      TFHelper_0123456789876543210 CK CW = FalseSym0
+      TFHelper_0123456789876543210 CK CX = FalseSym0
+      TFHelper_0123456789876543210 CK CY = FalseSym0
+      TFHelper_0123456789876543210 CK CZ = FalseSym0
+      TFHelper_0123456789876543210 CL CA = FalseSym0
+      TFHelper_0123456789876543210 CL CB = FalseSym0
+      TFHelper_0123456789876543210 CL CC = FalseSym0
+      TFHelper_0123456789876543210 CL CD = FalseSym0
+      TFHelper_0123456789876543210 CL CE = FalseSym0
+      TFHelper_0123456789876543210 CL CF = FalseSym0
+      TFHelper_0123456789876543210 CL CG = FalseSym0
+      TFHelper_0123456789876543210 CL CH = FalseSym0
+      TFHelper_0123456789876543210 CL CI = FalseSym0
+      TFHelper_0123456789876543210 CL CJ = FalseSym0
+      TFHelper_0123456789876543210 CL CK = FalseSym0
+      TFHelper_0123456789876543210 CL CL = TrueSym0
+      TFHelper_0123456789876543210 CL CM = FalseSym0
+      TFHelper_0123456789876543210 CL CN = FalseSym0
+      TFHelper_0123456789876543210 CL CO = FalseSym0
+      TFHelper_0123456789876543210 CL CP = FalseSym0
+      TFHelper_0123456789876543210 CL CQ = FalseSym0
+      TFHelper_0123456789876543210 CL CR = FalseSym0
+      TFHelper_0123456789876543210 CL CS = FalseSym0
+      TFHelper_0123456789876543210 CL CT = FalseSym0
+      TFHelper_0123456789876543210 CL CU = FalseSym0
+      TFHelper_0123456789876543210 CL CV = FalseSym0
+      TFHelper_0123456789876543210 CL CW = FalseSym0
+      TFHelper_0123456789876543210 CL CX = FalseSym0
+      TFHelper_0123456789876543210 CL CY = FalseSym0
+      TFHelper_0123456789876543210 CL CZ = FalseSym0
+      TFHelper_0123456789876543210 CM CA = FalseSym0
+      TFHelper_0123456789876543210 CM CB = FalseSym0
+      TFHelper_0123456789876543210 CM CC = FalseSym0
+      TFHelper_0123456789876543210 CM CD = FalseSym0
+      TFHelper_0123456789876543210 CM CE = FalseSym0
+      TFHelper_0123456789876543210 CM CF = FalseSym0
+      TFHelper_0123456789876543210 CM CG = FalseSym0
+      TFHelper_0123456789876543210 CM CH = FalseSym0
+      TFHelper_0123456789876543210 CM CI = FalseSym0
+      TFHelper_0123456789876543210 CM CJ = FalseSym0
+      TFHelper_0123456789876543210 CM CK = FalseSym0
+      TFHelper_0123456789876543210 CM CL = FalseSym0
+      TFHelper_0123456789876543210 CM CM = TrueSym0
+      TFHelper_0123456789876543210 CM CN = FalseSym0
+      TFHelper_0123456789876543210 CM CO = FalseSym0
+      TFHelper_0123456789876543210 CM CP = FalseSym0
+      TFHelper_0123456789876543210 CM CQ = FalseSym0
+      TFHelper_0123456789876543210 CM CR = FalseSym0
+      TFHelper_0123456789876543210 CM CS = FalseSym0
+      TFHelper_0123456789876543210 CM CT = FalseSym0
+      TFHelper_0123456789876543210 CM CU = FalseSym0
+      TFHelper_0123456789876543210 CM CV = FalseSym0
+      TFHelper_0123456789876543210 CM CW = FalseSym0
+      TFHelper_0123456789876543210 CM CX = FalseSym0
+      TFHelper_0123456789876543210 CM CY = FalseSym0
+      TFHelper_0123456789876543210 CM CZ = FalseSym0
+      TFHelper_0123456789876543210 CN CA = FalseSym0
+      TFHelper_0123456789876543210 CN CB = FalseSym0
+      TFHelper_0123456789876543210 CN CC = FalseSym0
+      TFHelper_0123456789876543210 CN CD = FalseSym0
+      TFHelper_0123456789876543210 CN CE = FalseSym0
+      TFHelper_0123456789876543210 CN CF = FalseSym0
+      TFHelper_0123456789876543210 CN CG = FalseSym0
+      TFHelper_0123456789876543210 CN CH = FalseSym0
+      TFHelper_0123456789876543210 CN CI = FalseSym0
+      TFHelper_0123456789876543210 CN CJ = FalseSym0
+      TFHelper_0123456789876543210 CN CK = FalseSym0
+      TFHelper_0123456789876543210 CN CL = FalseSym0
+      TFHelper_0123456789876543210 CN CM = FalseSym0
+      TFHelper_0123456789876543210 CN CN = TrueSym0
+      TFHelper_0123456789876543210 CN CO = FalseSym0
+      TFHelper_0123456789876543210 CN CP = FalseSym0
+      TFHelper_0123456789876543210 CN CQ = FalseSym0
+      TFHelper_0123456789876543210 CN CR = FalseSym0
+      TFHelper_0123456789876543210 CN CS = FalseSym0
+      TFHelper_0123456789876543210 CN CT = FalseSym0
+      TFHelper_0123456789876543210 CN CU = FalseSym0
+      TFHelper_0123456789876543210 CN CV = FalseSym0
+      TFHelper_0123456789876543210 CN CW = FalseSym0
+      TFHelper_0123456789876543210 CN CX = FalseSym0
+      TFHelper_0123456789876543210 CN CY = FalseSym0
+      TFHelper_0123456789876543210 CN CZ = FalseSym0
+      TFHelper_0123456789876543210 CO CA = FalseSym0
+      TFHelper_0123456789876543210 CO CB = FalseSym0
+      TFHelper_0123456789876543210 CO CC = FalseSym0
+      TFHelper_0123456789876543210 CO CD = FalseSym0
+      TFHelper_0123456789876543210 CO CE = FalseSym0
+      TFHelper_0123456789876543210 CO CF = FalseSym0
+      TFHelper_0123456789876543210 CO CG = FalseSym0
+      TFHelper_0123456789876543210 CO CH = FalseSym0
+      TFHelper_0123456789876543210 CO CI = FalseSym0
+      TFHelper_0123456789876543210 CO CJ = FalseSym0
+      TFHelper_0123456789876543210 CO CK = FalseSym0
+      TFHelper_0123456789876543210 CO CL = FalseSym0
+      TFHelper_0123456789876543210 CO CM = FalseSym0
+      TFHelper_0123456789876543210 CO CN = FalseSym0
+      TFHelper_0123456789876543210 CO CO = TrueSym0
+      TFHelper_0123456789876543210 CO CP = FalseSym0
+      TFHelper_0123456789876543210 CO CQ = FalseSym0
+      TFHelper_0123456789876543210 CO CR = FalseSym0
+      TFHelper_0123456789876543210 CO CS = FalseSym0
+      TFHelper_0123456789876543210 CO CT = FalseSym0
+      TFHelper_0123456789876543210 CO CU = FalseSym0
+      TFHelper_0123456789876543210 CO CV = FalseSym0
+      TFHelper_0123456789876543210 CO CW = FalseSym0
+      TFHelper_0123456789876543210 CO CX = FalseSym0
+      TFHelper_0123456789876543210 CO CY = FalseSym0
+      TFHelper_0123456789876543210 CO CZ = FalseSym0
+      TFHelper_0123456789876543210 CP CA = FalseSym0
+      TFHelper_0123456789876543210 CP CB = FalseSym0
+      TFHelper_0123456789876543210 CP CC = FalseSym0
+      TFHelper_0123456789876543210 CP CD = FalseSym0
+      TFHelper_0123456789876543210 CP CE = FalseSym0
+      TFHelper_0123456789876543210 CP CF = FalseSym0
+      TFHelper_0123456789876543210 CP CG = FalseSym0
+      TFHelper_0123456789876543210 CP CH = FalseSym0
+      TFHelper_0123456789876543210 CP CI = FalseSym0
+      TFHelper_0123456789876543210 CP CJ = FalseSym0
+      TFHelper_0123456789876543210 CP CK = FalseSym0
+      TFHelper_0123456789876543210 CP CL = FalseSym0
+      TFHelper_0123456789876543210 CP CM = FalseSym0
+      TFHelper_0123456789876543210 CP CN = FalseSym0
+      TFHelper_0123456789876543210 CP CO = FalseSym0
+      TFHelper_0123456789876543210 CP CP = TrueSym0
+      TFHelper_0123456789876543210 CP CQ = FalseSym0
+      TFHelper_0123456789876543210 CP CR = FalseSym0
+      TFHelper_0123456789876543210 CP CS = FalseSym0
+      TFHelper_0123456789876543210 CP CT = FalseSym0
+      TFHelper_0123456789876543210 CP CU = FalseSym0
+      TFHelper_0123456789876543210 CP CV = FalseSym0
+      TFHelper_0123456789876543210 CP CW = FalseSym0
+      TFHelper_0123456789876543210 CP CX = FalseSym0
+      TFHelper_0123456789876543210 CP CY = FalseSym0
+      TFHelper_0123456789876543210 CP CZ = FalseSym0
+      TFHelper_0123456789876543210 CQ CA = FalseSym0
+      TFHelper_0123456789876543210 CQ CB = FalseSym0
+      TFHelper_0123456789876543210 CQ CC = FalseSym0
+      TFHelper_0123456789876543210 CQ CD = FalseSym0
+      TFHelper_0123456789876543210 CQ CE = FalseSym0
+      TFHelper_0123456789876543210 CQ CF = FalseSym0
+      TFHelper_0123456789876543210 CQ CG = FalseSym0
+      TFHelper_0123456789876543210 CQ CH = FalseSym0
+      TFHelper_0123456789876543210 CQ CI = FalseSym0
+      TFHelper_0123456789876543210 CQ CJ = FalseSym0
+      TFHelper_0123456789876543210 CQ CK = FalseSym0
+      TFHelper_0123456789876543210 CQ CL = FalseSym0
+      TFHelper_0123456789876543210 CQ CM = FalseSym0
+      TFHelper_0123456789876543210 CQ CN = FalseSym0
+      TFHelper_0123456789876543210 CQ CO = FalseSym0
+      TFHelper_0123456789876543210 CQ CP = FalseSym0
+      TFHelper_0123456789876543210 CQ CQ = TrueSym0
+      TFHelper_0123456789876543210 CQ CR = FalseSym0
+      TFHelper_0123456789876543210 CQ CS = FalseSym0
+      TFHelper_0123456789876543210 CQ CT = FalseSym0
+      TFHelper_0123456789876543210 CQ CU = FalseSym0
+      TFHelper_0123456789876543210 CQ CV = FalseSym0
+      TFHelper_0123456789876543210 CQ CW = FalseSym0
+      TFHelper_0123456789876543210 CQ CX = FalseSym0
+      TFHelper_0123456789876543210 CQ CY = FalseSym0
+      TFHelper_0123456789876543210 CQ CZ = FalseSym0
+      TFHelper_0123456789876543210 CR CA = FalseSym0
+      TFHelper_0123456789876543210 CR CB = FalseSym0
+      TFHelper_0123456789876543210 CR CC = FalseSym0
+      TFHelper_0123456789876543210 CR CD = FalseSym0
+      TFHelper_0123456789876543210 CR CE = FalseSym0
+      TFHelper_0123456789876543210 CR CF = FalseSym0
+      TFHelper_0123456789876543210 CR CG = FalseSym0
+      TFHelper_0123456789876543210 CR CH = FalseSym0
+      TFHelper_0123456789876543210 CR CI = FalseSym0
+      TFHelper_0123456789876543210 CR CJ = FalseSym0
+      TFHelper_0123456789876543210 CR CK = FalseSym0
+      TFHelper_0123456789876543210 CR CL = FalseSym0
+      TFHelper_0123456789876543210 CR CM = FalseSym0
+      TFHelper_0123456789876543210 CR CN = FalseSym0
+      TFHelper_0123456789876543210 CR CO = FalseSym0
+      TFHelper_0123456789876543210 CR CP = FalseSym0
+      TFHelper_0123456789876543210 CR CQ = FalseSym0
+      TFHelper_0123456789876543210 CR CR = TrueSym0
+      TFHelper_0123456789876543210 CR CS = FalseSym0
+      TFHelper_0123456789876543210 CR CT = FalseSym0
+      TFHelper_0123456789876543210 CR CU = FalseSym0
+      TFHelper_0123456789876543210 CR CV = FalseSym0
+      TFHelper_0123456789876543210 CR CW = FalseSym0
+      TFHelper_0123456789876543210 CR CX = FalseSym0
+      TFHelper_0123456789876543210 CR CY = FalseSym0
+      TFHelper_0123456789876543210 CR CZ = FalseSym0
+      TFHelper_0123456789876543210 CS CA = FalseSym0
+      TFHelper_0123456789876543210 CS CB = FalseSym0
+      TFHelper_0123456789876543210 CS CC = FalseSym0
+      TFHelper_0123456789876543210 CS CD = FalseSym0
+      TFHelper_0123456789876543210 CS CE = FalseSym0
+      TFHelper_0123456789876543210 CS CF = FalseSym0
+      TFHelper_0123456789876543210 CS CG = FalseSym0
+      TFHelper_0123456789876543210 CS CH = FalseSym0
+      TFHelper_0123456789876543210 CS CI = FalseSym0
+      TFHelper_0123456789876543210 CS CJ = FalseSym0
+      TFHelper_0123456789876543210 CS CK = FalseSym0
+      TFHelper_0123456789876543210 CS CL = FalseSym0
+      TFHelper_0123456789876543210 CS CM = FalseSym0
+      TFHelper_0123456789876543210 CS CN = FalseSym0
+      TFHelper_0123456789876543210 CS CO = FalseSym0
+      TFHelper_0123456789876543210 CS CP = FalseSym0
+      TFHelper_0123456789876543210 CS CQ = FalseSym0
+      TFHelper_0123456789876543210 CS CR = FalseSym0
+      TFHelper_0123456789876543210 CS CS = TrueSym0
+      TFHelper_0123456789876543210 CS CT = FalseSym0
+      TFHelper_0123456789876543210 CS CU = FalseSym0
+      TFHelper_0123456789876543210 CS CV = FalseSym0
+      TFHelper_0123456789876543210 CS CW = FalseSym0
+      TFHelper_0123456789876543210 CS CX = FalseSym0
+      TFHelper_0123456789876543210 CS CY = FalseSym0
+      TFHelper_0123456789876543210 CS CZ = FalseSym0
+      TFHelper_0123456789876543210 CT CA = FalseSym0
+      TFHelper_0123456789876543210 CT CB = FalseSym0
+      TFHelper_0123456789876543210 CT CC = FalseSym0
+      TFHelper_0123456789876543210 CT CD = FalseSym0
+      TFHelper_0123456789876543210 CT CE = FalseSym0
+      TFHelper_0123456789876543210 CT CF = FalseSym0
+      TFHelper_0123456789876543210 CT CG = FalseSym0
+      TFHelper_0123456789876543210 CT CH = FalseSym0
+      TFHelper_0123456789876543210 CT CI = FalseSym0
+      TFHelper_0123456789876543210 CT CJ = FalseSym0
+      TFHelper_0123456789876543210 CT CK = FalseSym0
+      TFHelper_0123456789876543210 CT CL = FalseSym0
+      TFHelper_0123456789876543210 CT CM = FalseSym0
+      TFHelper_0123456789876543210 CT CN = FalseSym0
+      TFHelper_0123456789876543210 CT CO = FalseSym0
+      TFHelper_0123456789876543210 CT CP = FalseSym0
+      TFHelper_0123456789876543210 CT CQ = FalseSym0
+      TFHelper_0123456789876543210 CT CR = FalseSym0
+      TFHelper_0123456789876543210 CT CS = FalseSym0
+      TFHelper_0123456789876543210 CT CT = TrueSym0
+      TFHelper_0123456789876543210 CT CU = FalseSym0
+      TFHelper_0123456789876543210 CT CV = FalseSym0
+      TFHelper_0123456789876543210 CT CW = FalseSym0
+      TFHelper_0123456789876543210 CT CX = FalseSym0
+      TFHelper_0123456789876543210 CT CY = FalseSym0
+      TFHelper_0123456789876543210 CT CZ = FalseSym0
+      TFHelper_0123456789876543210 CU CA = FalseSym0
+      TFHelper_0123456789876543210 CU CB = FalseSym0
+      TFHelper_0123456789876543210 CU CC = FalseSym0
+      TFHelper_0123456789876543210 CU CD = FalseSym0
+      TFHelper_0123456789876543210 CU CE = FalseSym0
+      TFHelper_0123456789876543210 CU CF = FalseSym0
+      TFHelper_0123456789876543210 CU CG = FalseSym0
+      TFHelper_0123456789876543210 CU CH = FalseSym0
+      TFHelper_0123456789876543210 CU CI = FalseSym0
+      TFHelper_0123456789876543210 CU CJ = FalseSym0
+      TFHelper_0123456789876543210 CU CK = FalseSym0
+      TFHelper_0123456789876543210 CU CL = FalseSym0
+      TFHelper_0123456789876543210 CU CM = FalseSym0
+      TFHelper_0123456789876543210 CU CN = FalseSym0
+      TFHelper_0123456789876543210 CU CO = FalseSym0
+      TFHelper_0123456789876543210 CU CP = FalseSym0
+      TFHelper_0123456789876543210 CU CQ = FalseSym0
+      TFHelper_0123456789876543210 CU CR = FalseSym0
+      TFHelper_0123456789876543210 CU CS = FalseSym0
+      TFHelper_0123456789876543210 CU CT = FalseSym0
+      TFHelper_0123456789876543210 CU CU = TrueSym0
+      TFHelper_0123456789876543210 CU CV = FalseSym0
+      TFHelper_0123456789876543210 CU CW = FalseSym0
+      TFHelper_0123456789876543210 CU CX = FalseSym0
+      TFHelper_0123456789876543210 CU CY = FalseSym0
+      TFHelper_0123456789876543210 CU CZ = FalseSym0
+      TFHelper_0123456789876543210 CV CA = FalseSym0
+      TFHelper_0123456789876543210 CV CB = FalseSym0
+      TFHelper_0123456789876543210 CV CC = FalseSym0
+      TFHelper_0123456789876543210 CV CD = FalseSym0
+      TFHelper_0123456789876543210 CV CE = FalseSym0
+      TFHelper_0123456789876543210 CV CF = FalseSym0
+      TFHelper_0123456789876543210 CV CG = FalseSym0
+      TFHelper_0123456789876543210 CV CH = FalseSym0
+      TFHelper_0123456789876543210 CV CI = FalseSym0
+      TFHelper_0123456789876543210 CV CJ = FalseSym0
+      TFHelper_0123456789876543210 CV CK = FalseSym0
+      TFHelper_0123456789876543210 CV CL = FalseSym0
+      TFHelper_0123456789876543210 CV CM = FalseSym0
+      TFHelper_0123456789876543210 CV CN = FalseSym0
+      TFHelper_0123456789876543210 CV CO = FalseSym0
+      TFHelper_0123456789876543210 CV CP = FalseSym0
+      TFHelper_0123456789876543210 CV CQ = FalseSym0
+      TFHelper_0123456789876543210 CV CR = FalseSym0
+      TFHelper_0123456789876543210 CV CS = FalseSym0
+      TFHelper_0123456789876543210 CV CT = FalseSym0
+      TFHelper_0123456789876543210 CV CU = FalseSym0
+      TFHelper_0123456789876543210 CV CV = TrueSym0
+      TFHelper_0123456789876543210 CV CW = FalseSym0
+      TFHelper_0123456789876543210 CV CX = FalseSym0
+      TFHelper_0123456789876543210 CV CY = FalseSym0
+      TFHelper_0123456789876543210 CV CZ = FalseSym0
+      TFHelper_0123456789876543210 CW CA = FalseSym0
+      TFHelper_0123456789876543210 CW CB = FalseSym0
+      TFHelper_0123456789876543210 CW CC = FalseSym0
+      TFHelper_0123456789876543210 CW CD = FalseSym0
+      TFHelper_0123456789876543210 CW CE = FalseSym0
+      TFHelper_0123456789876543210 CW CF = FalseSym0
+      TFHelper_0123456789876543210 CW CG = FalseSym0
+      TFHelper_0123456789876543210 CW CH = FalseSym0
+      TFHelper_0123456789876543210 CW CI = FalseSym0
+      TFHelper_0123456789876543210 CW CJ = FalseSym0
+      TFHelper_0123456789876543210 CW CK = FalseSym0
+      TFHelper_0123456789876543210 CW CL = FalseSym0
+      TFHelper_0123456789876543210 CW CM = FalseSym0
+      TFHelper_0123456789876543210 CW CN = FalseSym0
+      TFHelper_0123456789876543210 CW CO = FalseSym0
+      TFHelper_0123456789876543210 CW CP = FalseSym0
+      TFHelper_0123456789876543210 CW CQ = FalseSym0
+      TFHelper_0123456789876543210 CW CR = FalseSym0
+      TFHelper_0123456789876543210 CW CS = FalseSym0
+      TFHelper_0123456789876543210 CW CT = FalseSym0
+      TFHelper_0123456789876543210 CW CU = FalseSym0
+      TFHelper_0123456789876543210 CW CV = FalseSym0
+      TFHelper_0123456789876543210 CW CW = TrueSym0
+      TFHelper_0123456789876543210 CW CX = FalseSym0
+      TFHelper_0123456789876543210 CW CY = FalseSym0
+      TFHelper_0123456789876543210 CW CZ = FalseSym0
+      TFHelper_0123456789876543210 CX CA = FalseSym0
+      TFHelper_0123456789876543210 CX CB = FalseSym0
+      TFHelper_0123456789876543210 CX CC = FalseSym0
+      TFHelper_0123456789876543210 CX CD = FalseSym0
+      TFHelper_0123456789876543210 CX CE = FalseSym0
+      TFHelper_0123456789876543210 CX CF = FalseSym0
+      TFHelper_0123456789876543210 CX CG = FalseSym0
+      TFHelper_0123456789876543210 CX CH = FalseSym0
+      TFHelper_0123456789876543210 CX CI = FalseSym0
+      TFHelper_0123456789876543210 CX CJ = FalseSym0
+      TFHelper_0123456789876543210 CX CK = FalseSym0
+      TFHelper_0123456789876543210 CX CL = FalseSym0
+      TFHelper_0123456789876543210 CX CM = FalseSym0
+      TFHelper_0123456789876543210 CX CN = FalseSym0
+      TFHelper_0123456789876543210 CX CO = FalseSym0
+      TFHelper_0123456789876543210 CX CP = FalseSym0
+      TFHelper_0123456789876543210 CX CQ = FalseSym0
+      TFHelper_0123456789876543210 CX CR = FalseSym0
+      TFHelper_0123456789876543210 CX CS = FalseSym0
+      TFHelper_0123456789876543210 CX CT = FalseSym0
+      TFHelper_0123456789876543210 CX CU = FalseSym0
+      TFHelper_0123456789876543210 CX CV = FalseSym0
+      TFHelper_0123456789876543210 CX CW = FalseSym0
+      TFHelper_0123456789876543210 CX CX = TrueSym0
+      TFHelper_0123456789876543210 CX CY = FalseSym0
+      TFHelper_0123456789876543210 CX CZ = FalseSym0
+      TFHelper_0123456789876543210 CY CA = FalseSym0
+      TFHelper_0123456789876543210 CY CB = FalseSym0
+      TFHelper_0123456789876543210 CY CC = FalseSym0
+      TFHelper_0123456789876543210 CY CD = FalseSym0
+      TFHelper_0123456789876543210 CY CE = FalseSym0
+      TFHelper_0123456789876543210 CY CF = FalseSym0
+      TFHelper_0123456789876543210 CY CG = FalseSym0
+      TFHelper_0123456789876543210 CY CH = FalseSym0
+      TFHelper_0123456789876543210 CY CI = FalseSym0
+      TFHelper_0123456789876543210 CY CJ = FalseSym0
+      TFHelper_0123456789876543210 CY CK = FalseSym0
+      TFHelper_0123456789876543210 CY CL = FalseSym0
+      TFHelper_0123456789876543210 CY CM = FalseSym0
+      TFHelper_0123456789876543210 CY CN = FalseSym0
+      TFHelper_0123456789876543210 CY CO = FalseSym0
+      TFHelper_0123456789876543210 CY CP = FalseSym0
+      TFHelper_0123456789876543210 CY CQ = FalseSym0
+      TFHelper_0123456789876543210 CY CR = FalseSym0
+      TFHelper_0123456789876543210 CY CS = FalseSym0
+      TFHelper_0123456789876543210 CY CT = FalseSym0
+      TFHelper_0123456789876543210 CY CU = FalseSym0
+      TFHelper_0123456789876543210 CY CV = FalseSym0
+      TFHelper_0123456789876543210 CY CW = FalseSym0
+      TFHelper_0123456789876543210 CY CX = FalseSym0
+      TFHelper_0123456789876543210 CY CY = TrueSym0
+      TFHelper_0123456789876543210 CY CZ = FalseSym0
+      TFHelper_0123456789876543210 CZ CA = FalseSym0
+      TFHelper_0123456789876543210 CZ CB = FalseSym0
+      TFHelper_0123456789876543210 CZ CC = FalseSym0
+      TFHelper_0123456789876543210 CZ CD = FalseSym0
+      TFHelper_0123456789876543210 CZ CE = FalseSym0
+      TFHelper_0123456789876543210 CZ CF = FalseSym0
+      TFHelper_0123456789876543210 CZ CG = FalseSym0
+      TFHelper_0123456789876543210 CZ CH = FalseSym0
+      TFHelper_0123456789876543210 CZ CI = FalseSym0
+      TFHelper_0123456789876543210 CZ CJ = FalseSym0
+      TFHelper_0123456789876543210 CZ CK = FalseSym0
+      TFHelper_0123456789876543210 CZ CL = FalseSym0
+      TFHelper_0123456789876543210 CZ CM = FalseSym0
+      TFHelper_0123456789876543210 CZ CN = FalseSym0
+      TFHelper_0123456789876543210 CZ CO = FalseSym0
+      TFHelper_0123456789876543210 CZ CP = FalseSym0
+      TFHelper_0123456789876543210 CZ CQ = FalseSym0
+      TFHelper_0123456789876543210 CZ CR = FalseSym0
+      TFHelper_0123456789876543210 CZ CS = FalseSym0
+      TFHelper_0123456789876543210 CZ CT = FalseSym0
+      TFHelper_0123456789876543210 CZ CU = FalseSym0
+      TFHelper_0123456789876543210 CZ CV = FalseSym0
+      TFHelper_0123456789876543210 CZ CW = FalseSym0
+      TFHelper_0123456789876543210 CZ CX = FalseSym0
+      TFHelper_0123456789876543210 CZ CY = FalseSym0
+      TFHelper_0123456789876543210 CZ CZ = TrueSym0
+    instance PEq AChar where
+      type (==) a a = TFHelper_0123456789876543210 a a
+    sLookup ::
+      (forall (t :: [AChar]) (t :: Schema).
+       Sing t -> Sing t -> Sing (Lookup t t :: U) :: Type)
+    sOccurs ::
+      (forall (t :: [AChar]) (t :: Schema).
+       Sing t -> Sing t -> Sing (Occurs t t :: Bool) :: Type)
+    sDisjoint ::
+      (forall (t :: Schema) (t :: Schema).
+       Sing t -> Sing t -> Sing (Disjoint t t :: Bool) :: Type)
+    sAttrNotIn ::
+      (forall (t :: Attribute) (t :: Schema).
+       Sing t -> Sing t -> Sing (AttrNotIn t t :: Bool) :: Type)
+    sAppend ::
+      (forall (t :: Schema) (t :: Schema).
+       Sing t -> Sing t -> Sing (Append t t :: Schema) :: Type)
+    sLookup _ (SSch SNil) = sUndefined
+    sLookup
+      (sName :: Sing name)
+      (SSch (SCons (SAttr (sName' :: Sing name') (sU :: Sing u))
+                   (sAttrs :: Sing attrs)))
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 name name' u attrs)
+             (\cases
+                STrue -> sU
+                SFalse
+                  -> applySing
+                       (applySing (singFun2 @LookupSym0 sLookup) sName)
+                       (applySing (singFun1 @SchSym0 SSch) sAttrs)))
+          (applySing (applySing (singFun2 @(==@#@$) (%==)) sName) sName')
+    sOccurs _ (SSch SNil) = SFalse
+    sOccurs
+      (sName :: Sing name)
+      (SSch (SCons (SAttr (sName' :: Sing name') _)
+                   (sAttrs :: Sing attrs)))
+      = applySing
+          (applySing
+             (singFun2 @(||@#@$) (%||))
+             (applySing (applySing (singFun2 @(==@#@$) (%==)) sName) sName'))
+          (applySing
+             (applySing (singFun2 @OccursSym0 sOccurs) sName)
+             (applySing (singFun1 @SchSym0 SSch) sAttrs))
+    sDisjoint (SSch SNil) _ = STrue
+    sDisjoint
+      (SSch (SCons (sH :: Sing h) (sT :: Sing t)))
+      (sS :: Sing s)
+      = applySing
+          (applySing
+             (singFun2 @(&&@#@$) (%&&))
+             (applySing (applySing (singFun2 @AttrNotInSym0 sAttrNotIn) sH) sS))
+          (applySing
+             (applySing
+                (singFun2 @DisjointSym0 sDisjoint)
+                (applySing (singFun1 @SchSym0 SSch) sT))
+             sS)
+    sAttrNotIn _ (SSch SNil) = STrue
+    sAttrNotIn
+      (SAttr (sName :: Sing name) (sU :: Sing u))
+      (SSch (SCons (SAttr (sName' :: Sing name') _) (sT :: Sing t)))
+      = applySing
+          (applySing
+             (singFun2 @(&&@#@$) (%&&))
+             (applySing (applySing (singFun2 @(/=@#@$) (%/=)) sName) sName'))
+          (applySing
+             (applySing
+                (singFun2 @AttrNotInSym0 sAttrNotIn)
+                (applySing (applySing (singFun2 @AttrSym0 SAttr) sName) sU))
+             (applySing (singFun1 @SchSym0 SSch) sT))
+    sAppend (SSch (sS1 :: Sing s1)) (SSch (sS2 :: Sing s2))
+      = applySing
+          (singFun1 @SchSym0 SSch)
+          (applySing (applySing (singFun2 @(++@#@$) (%++)) sS1) sS2)
+    instance SingI (LookupSym0 :: (~>) [AChar] ((~>) Schema U)) where
+      sing = singFun2 @LookupSym0 sLookup
+    instance SingI d =>
+             SingI (LookupSym1 (d :: [AChar]) :: (~>) Schema U) where
+      sing = singFun1 @(LookupSym1 (d :: [AChar])) (sLookup (sing @d))
+    instance SingI1 (LookupSym1 :: [AChar] -> (~>) Schema U) where
+      liftSing (s :: Sing (d :: [AChar]))
+        = singFun1 @(LookupSym1 (d :: [AChar])) (sLookup s)
+    instance SingI (OccursSym0 :: (~>) [AChar] ((~>) Schema Bool)) where
+      sing = singFun2 @OccursSym0 sOccurs
+    instance SingI d =>
+             SingI (OccursSym1 (d :: [AChar]) :: (~>) Schema Bool) where
+      sing = singFun1 @(OccursSym1 (d :: [AChar])) (sOccurs (sing @d))
+    instance SingI1 (OccursSym1 :: [AChar] -> (~>) Schema Bool) where
+      liftSing (s :: Sing (d :: [AChar]))
+        = singFun1 @(OccursSym1 (d :: [AChar])) (sOccurs s)
+    instance SingI (DisjointSym0 :: (~>) Schema ((~>) Schema Bool)) where
+      sing = singFun2 @DisjointSym0 sDisjoint
+    instance SingI d =>
+             SingI (DisjointSym1 (d :: Schema) :: (~>) Schema Bool) where
+      sing = singFun1 @(DisjointSym1 (d :: Schema)) (sDisjoint (sing @d))
+    instance SingI1 (DisjointSym1 :: Schema -> (~>) Schema Bool) where
+      liftSing (s :: Sing (d :: Schema))
+        = singFun1 @(DisjointSym1 (d :: Schema)) (sDisjoint s)
+    instance SingI (AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool)) where
+      sing = singFun2 @AttrNotInSym0 sAttrNotIn
+    instance SingI d =>
+             SingI (AttrNotInSym1 (d :: Attribute) :: (~>) Schema Bool) where
+      sing
+        = singFun1 @(AttrNotInSym1 (d :: Attribute)) (sAttrNotIn (sing @d))
+    instance SingI1 (AttrNotInSym1 :: Attribute
+                                      -> (~>) Schema Bool) where
+      liftSing (s :: Sing (d :: Attribute))
+        = singFun1 @(AttrNotInSym1 (d :: Attribute)) (sAttrNotIn s)
+    instance SingI (AppendSym0 :: (~>) Schema ((~>) Schema Schema)) where
+      sing = singFun2 @AppendSym0 sAppend
+    instance SingI d =>
+             SingI (AppendSym1 (d :: Schema) :: (~>) Schema Schema) where
+      sing = singFun1 @(AppendSym1 (d :: Schema)) (sAppend (sing @d))
+    instance SingI1 (AppendSym1 :: Schema -> (~>) Schema Schema) where
+      liftSing (s :: Sing (d :: Schema))
+        = singFun1 @(AppendSym1 (d :: Schema)) (sAppend s)
+    data SU :: U -> Type
+      where
+        SBOOL :: SU (BOOL :: U)
+        SSTRING :: SU (STRING :: U)
+        SNAT :: SU (NAT :: U)
+        SVEC :: forall (n :: U) (n :: Nat).
+                (Sing n) -> (Sing n) -> SU (VEC n n :: U)
+    type instance Sing @U = SU
+    instance SingKind U where
+      type Demote U = U
+      fromSing SBOOL = BOOL
+      fromSing SSTRING = STRING
+      fromSing SNAT = NAT
+      fromSing (SVEC b b) = VEC (fromSing b) (fromSing b)
+      toSing BOOL = SomeSing SBOOL
+      toSing STRING = SomeSing SSTRING
+      toSing NAT = SomeSing SNAT
+      toSing (VEC (b :: Demote U) (b :: Demote Nat))
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SVEC c c))
+            (toSing b :: SomeSing U) (toSing b :: SomeSing Nat)
+    data SAChar :: AChar -> Type
+      where
+        SCA :: SAChar (CA :: AChar)
+        SCB :: SAChar (CB :: AChar)
+        SCC :: SAChar (CC :: AChar)
+        SCD :: SAChar (CD :: AChar)
+        SCE :: SAChar (CE :: AChar)
+        SCF :: SAChar (CF :: AChar)
+        SCG :: SAChar (CG :: AChar)
+        SCH :: SAChar (CH :: AChar)
+        SCI :: SAChar (CI :: AChar)
+        SCJ :: SAChar (CJ :: AChar)
+        SCK :: SAChar (CK :: AChar)
+        SCL :: SAChar (CL :: AChar)
+        SCM :: SAChar (CM :: AChar)
+        SCN :: SAChar (CN :: AChar)
+        SCO :: SAChar (CO :: AChar)
+        SCP :: SAChar (CP :: AChar)
+        SCQ :: SAChar (CQ :: AChar)
+        SCR :: SAChar (CR :: AChar)
+        SCS :: SAChar (CS :: AChar)
+        SCT :: SAChar (CT :: AChar)
+        SCU :: SAChar (CU :: AChar)
+        SCV :: SAChar (CV :: AChar)
+        SCW :: SAChar (CW :: AChar)
+        SCX :: SAChar (CX :: AChar)
+        SCY :: SAChar (CY :: AChar)
+        SCZ :: SAChar (CZ :: AChar)
+    type instance Sing @AChar = SAChar
+    instance SingKind AChar where
+      type Demote AChar = AChar
+      fromSing SCA = CA
+      fromSing SCB = CB
+      fromSing SCC = CC
+      fromSing SCD = CD
+      fromSing SCE = CE
+      fromSing SCF = CF
+      fromSing SCG = CG
+      fromSing SCH = CH
+      fromSing SCI = CI
+      fromSing SCJ = CJ
+      fromSing SCK = CK
+      fromSing SCL = CL
+      fromSing SCM = CM
+      fromSing SCN = CN
+      fromSing SCO = CO
+      fromSing SCP = CP
+      fromSing SCQ = CQ
+      fromSing SCR = CR
+      fromSing SCS = CS
+      fromSing SCT = CT
+      fromSing SCU = CU
+      fromSing SCV = CV
+      fromSing SCW = CW
+      fromSing SCX = CX
+      fromSing SCY = CY
+      fromSing SCZ = CZ
+      toSing CA = SomeSing SCA
+      toSing CB = SomeSing SCB
+      toSing CC = SomeSing SCC
+      toSing CD = SomeSing SCD
+      toSing CE = SomeSing SCE
+      toSing CF = SomeSing SCF
+      toSing CG = SomeSing SCG
+      toSing CH = SomeSing SCH
+      toSing CI = SomeSing SCI
+      toSing CJ = SomeSing SCJ
+      toSing CK = SomeSing SCK
+      toSing CL = SomeSing SCL
+      toSing CM = SomeSing SCM
+      toSing CN = SomeSing SCN
+      toSing CO = SomeSing SCO
+      toSing CP = SomeSing SCP
+      toSing CQ = SomeSing SCQ
+      toSing CR = SomeSing SCR
+      toSing CS = SomeSing SCS
+      toSing CT = SomeSing SCT
+      toSing CU = SomeSing SCU
+      toSing CV = SomeSing SCV
+      toSing CW = SomeSing SCW
+      toSing CX = SomeSing SCX
+      toSing CY = SomeSing SCY
+      toSing CZ = SomeSing SCZ
+    data SAttribute :: Attribute -> Type
+      where
+        SAttr :: forall (n :: [AChar]) (n :: U).
+                 (Sing n) -> (Sing n) -> SAttribute (Attr n n :: Attribute)
+    type instance Sing @Attribute = SAttribute
+    instance SingKind Attribute where
+      type Demote Attribute = Attribute
+      fromSing (SAttr b b) = Attr (fromSing b) (fromSing b)
+      toSing (Attr (b :: Demote [AChar]) (b :: Demote U))
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SAttr c c))
+            (toSing b :: SomeSing [AChar]) (toSing b :: SomeSing U)
+    data SSchema :: Schema -> Type
+      where
+        SSch :: forall (n :: [Attribute]).
+                (Sing n) -> SSchema (Sch n :: Schema)
+    type instance Sing @Schema = SSchema
+    instance SingKind Schema where
+      type Demote Schema = Schema
+      fromSing (SSch b) = Sch (fromSing b)
+      toSing (Sch (b :: Demote [Attribute]))
+        = (\cases (SomeSing c) -> SomeSing (SSch c))
+            (toSing b :: SomeSing [Attribute])
+    instance (SEq U, SEq Nat) => SEq U where
+      (%==) SBOOL SBOOL = STrue
+      (%==) SBOOL SSTRING = SFalse
+      (%==) SBOOL SNAT = SFalse
+      (%==) SBOOL (SVEC _ _) = SFalse
+      (%==) SSTRING SBOOL = SFalse
+      (%==) SSTRING SSTRING = STrue
+      (%==) SSTRING SNAT = SFalse
+      (%==) SSTRING (SVEC _ _) = SFalse
+      (%==) SNAT SBOOL = SFalse
+      (%==) SNAT SSTRING = SFalse
+      (%==) SNAT SNAT = STrue
+      (%==) SNAT (SVEC _ _) = SFalse
+      (%==) (SVEC _ _) SBOOL = SFalse
+      (%==) (SVEC _ _) SSTRING = SFalse
+      (%==) (SVEC _ _) SNAT = SFalse
+      (%==)
+        (SVEC (sA_0123456789876543210 :: Sing a_0123456789876543210)
+              (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SVEC (sB_0123456789876543210 :: Sing b_0123456789876543210)
+              (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @(&&@#@$) (%&&))
+               (applySing
+                  (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                  sB_0123456789876543210))
+            (applySing
+               (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+               sB_0123456789876543210)
+    instance (SShow U, SShow Nat) => SShow U where
+      sShowsPrec
+        _
+        SBOOL
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "BOOL"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SSTRING
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "STRING"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SNAT
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "NAT"))
+            sA_0123456789876543210
+      sShowsPrec
+        (sP_0123456789876543210 :: Sing p_0123456789876543210)
+        (SVEC (sArg_0123456789876543210 :: Sing arg_0123456789876543210)
+              (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "VEC ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @(.@#@$) (%.))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun3 @(.@#@$) (%.)) (singFun1 @ShowSpaceSym0 sShowSpace))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210)))))
+            sA_0123456789876543210
+    instance SShow AChar where
+      sShowsPrec
+        _
+        SCA
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CA"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCB
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CB"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCC
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CC"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCD
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CD"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCE
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CE"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCF
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CF"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCG
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CG"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCH
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CH"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCI
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CI"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCJ
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CJ"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCK
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CK"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCL
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CL"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCM
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CM"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCN
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CN"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCO
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CO"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCP
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CP"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCQ
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CQ"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCR
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CR"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCS
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CS"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCT
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CT"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCU
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CU"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCV
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CV"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCW
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CW"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCX
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CX"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCY
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CY"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SCZ
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CZ"))
+            sA_0123456789876543210
+    instance SEq AChar where
+      (%==) SCA SCA = STrue
+      (%==) SCA SCB = SFalse
+      (%==) SCA SCC = SFalse
+      (%==) SCA SCD = SFalse
+      (%==) SCA SCE = SFalse
+      (%==) SCA SCF = SFalse
+      (%==) SCA SCG = SFalse
+      (%==) SCA SCH = SFalse
+      (%==) SCA SCI = SFalse
+      (%==) SCA SCJ = SFalse
+      (%==) SCA SCK = SFalse
+      (%==) SCA SCL = SFalse
+      (%==) SCA SCM = SFalse
+      (%==) SCA SCN = SFalse
+      (%==) SCA SCO = SFalse
+      (%==) SCA SCP = SFalse
+      (%==) SCA SCQ = SFalse
+      (%==) SCA SCR = SFalse
+      (%==) SCA SCS = SFalse
+      (%==) SCA SCT = SFalse
+      (%==) SCA SCU = SFalse
+      (%==) SCA SCV = SFalse
+      (%==) SCA SCW = SFalse
+      (%==) SCA SCX = SFalse
+      (%==) SCA SCY = SFalse
+      (%==) SCA SCZ = SFalse
+      (%==) SCB SCA = SFalse
+      (%==) SCB SCB = STrue
+      (%==) SCB SCC = SFalse
+      (%==) SCB SCD = SFalse
+      (%==) SCB SCE = SFalse
+      (%==) SCB SCF = SFalse
+      (%==) SCB SCG = SFalse
+      (%==) SCB SCH = SFalse
+      (%==) SCB SCI = SFalse
+      (%==) SCB SCJ = SFalse
+      (%==) SCB SCK = SFalse
+      (%==) SCB SCL = SFalse
+      (%==) SCB SCM = SFalse
+      (%==) SCB SCN = SFalse
+      (%==) SCB SCO = SFalse
+      (%==) SCB SCP = SFalse
+      (%==) SCB SCQ = SFalse
+      (%==) SCB SCR = SFalse
+      (%==) SCB SCS = SFalse
+      (%==) SCB SCT = SFalse
+      (%==) SCB SCU = SFalse
+      (%==) SCB SCV = SFalse
+      (%==) SCB SCW = SFalse
+      (%==) SCB SCX = SFalse
+      (%==) SCB SCY = SFalse
+      (%==) SCB SCZ = SFalse
+      (%==) SCC SCA = SFalse
+      (%==) SCC SCB = SFalse
+      (%==) SCC SCC = STrue
+      (%==) SCC SCD = SFalse
+      (%==) SCC SCE = SFalse
+      (%==) SCC SCF = SFalse
+      (%==) SCC SCG = SFalse
+      (%==) SCC SCH = SFalse
+      (%==) SCC SCI = SFalse
+      (%==) SCC SCJ = SFalse
+      (%==) SCC SCK = SFalse
+      (%==) SCC SCL = SFalse
+      (%==) SCC SCM = SFalse
+      (%==) SCC SCN = SFalse
+      (%==) SCC SCO = SFalse
+      (%==) SCC SCP = SFalse
+      (%==) SCC SCQ = SFalse
+      (%==) SCC SCR = SFalse
+      (%==) SCC SCS = SFalse
+      (%==) SCC SCT = SFalse
+      (%==) SCC SCU = SFalse
+      (%==) SCC SCV = SFalse
+      (%==) SCC SCW = SFalse
+      (%==) SCC SCX = SFalse
+      (%==) SCC SCY = SFalse
+      (%==) SCC SCZ = SFalse
+      (%==) SCD SCA = SFalse
+      (%==) SCD SCB = SFalse
+      (%==) SCD SCC = SFalse
+      (%==) SCD SCD = STrue
+      (%==) SCD SCE = SFalse
+      (%==) SCD SCF = SFalse
+      (%==) SCD SCG = SFalse
+      (%==) SCD SCH = SFalse
+      (%==) SCD SCI = SFalse
+      (%==) SCD SCJ = SFalse
+      (%==) SCD SCK = SFalse
+      (%==) SCD SCL = SFalse
+      (%==) SCD SCM = SFalse
+      (%==) SCD SCN = SFalse
+      (%==) SCD SCO = SFalse
+      (%==) SCD SCP = SFalse
+      (%==) SCD SCQ = SFalse
+      (%==) SCD SCR = SFalse
+      (%==) SCD SCS = SFalse
+      (%==) SCD SCT = SFalse
+      (%==) SCD SCU = SFalse
+      (%==) SCD SCV = SFalse
+      (%==) SCD SCW = SFalse
+      (%==) SCD SCX = SFalse
+      (%==) SCD SCY = SFalse
+      (%==) SCD SCZ = SFalse
+      (%==) SCE SCA = SFalse
+      (%==) SCE SCB = SFalse
+      (%==) SCE SCC = SFalse
+      (%==) SCE SCD = SFalse
+      (%==) SCE SCE = STrue
+      (%==) SCE SCF = SFalse
+      (%==) SCE SCG = SFalse
+      (%==) SCE SCH = SFalse
+      (%==) SCE SCI = SFalse
+      (%==) SCE SCJ = SFalse
+      (%==) SCE SCK = SFalse
+      (%==) SCE SCL = SFalse
+      (%==) SCE SCM = SFalse
+      (%==) SCE SCN = SFalse
+      (%==) SCE SCO = SFalse
+      (%==) SCE SCP = SFalse
+      (%==) SCE SCQ = SFalse
+      (%==) SCE SCR = SFalse
+      (%==) SCE SCS = SFalse
+      (%==) SCE SCT = SFalse
+      (%==) SCE SCU = SFalse
+      (%==) SCE SCV = SFalse
+      (%==) SCE SCW = SFalse
+      (%==) SCE SCX = SFalse
+      (%==) SCE SCY = SFalse
+      (%==) SCE SCZ = SFalse
+      (%==) SCF SCA = SFalse
+      (%==) SCF SCB = SFalse
+      (%==) SCF SCC = SFalse
+      (%==) SCF SCD = SFalse
+      (%==) SCF SCE = SFalse
+      (%==) SCF SCF = STrue
+      (%==) SCF SCG = SFalse
+      (%==) SCF SCH = SFalse
+      (%==) SCF SCI = SFalse
+      (%==) SCF SCJ = SFalse
+      (%==) SCF SCK = SFalse
+      (%==) SCF SCL = SFalse
+      (%==) SCF SCM = SFalse
+      (%==) SCF SCN = SFalse
+      (%==) SCF SCO = SFalse
+      (%==) SCF SCP = SFalse
+      (%==) SCF SCQ = SFalse
+      (%==) SCF SCR = SFalse
+      (%==) SCF SCS = SFalse
+      (%==) SCF SCT = SFalse
+      (%==) SCF SCU = SFalse
+      (%==) SCF SCV = SFalse
+      (%==) SCF SCW = SFalse
+      (%==) SCF SCX = SFalse
+      (%==) SCF SCY = SFalse
+      (%==) SCF SCZ = SFalse
+      (%==) SCG SCA = SFalse
+      (%==) SCG SCB = SFalse
+      (%==) SCG SCC = SFalse
+      (%==) SCG SCD = SFalse
+      (%==) SCG SCE = SFalse
+      (%==) SCG SCF = SFalse
+      (%==) SCG SCG = STrue
+      (%==) SCG SCH = SFalse
+      (%==) SCG SCI = SFalse
+      (%==) SCG SCJ = SFalse
+      (%==) SCG SCK = SFalse
+      (%==) SCG SCL = SFalse
+      (%==) SCG SCM = SFalse
+      (%==) SCG SCN = SFalse
+      (%==) SCG SCO = SFalse
+      (%==) SCG SCP = SFalse
+      (%==) SCG SCQ = SFalse
+      (%==) SCG SCR = SFalse
+      (%==) SCG SCS = SFalse
+      (%==) SCG SCT = SFalse
+      (%==) SCG SCU = SFalse
+      (%==) SCG SCV = SFalse
+      (%==) SCG SCW = SFalse
+      (%==) SCG SCX = SFalse
+      (%==) SCG SCY = SFalse
+      (%==) SCG SCZ = SFalse
+      (%==) SCH SCA = SFalse
+      (%==) SCH SCB = SFalse
+      (%==) SCH SCC = SFalse
+      (%==) SCH SCD = SFalse
+      (%==) SCH SCE = SFalse
+      (%==) SCH SCF = SFalse
+      (%==) SCH SCG = SFalse
+      (%==) SCH SCH = STrue
+      (%==) SCH SCI = SFalse
+      (%==) SCH SCJ = SFalse
+      (%==) SCH SCK = SFalse
+      (%==) SCH SCL = SFalse
+      (%==) SCH SCM = SFalse
+      (%==) SCH SCN = SFalse
+      (%==) SCH SCO = SFalse
+      (%==) SCH SCP = SFalse
+      (%==) SCH SCQ = SFalse
+      (%==) SCH SCR = SFalse
+      (%==) SCH SCS = SFalse
+      (%==) SCH SCT = SFalse
+      (%==) SCH SCU = SFalse
+      (%==) SCH SCV = SFalse
+      (%==) SCH SCW = SFalse
+      (%==) SCH SCX = SFalse
+      (%==) SCH SCY = SFalse
+      (%==) SCH SCZ = SFalse
+      (%==) SCI SCA = SFalse
+      (%==) SCI SCB = SFalse
+      (%==) SCI SCC = SFalse
+      (%==) SCI SCD = SFalse
+      (%==) SCI SCE = SFalse
+      (%==) SCI SCF = SFalse
+      (%==) SCI SCG = SFalse
+      (%==) SCI SCH = SFalse
+      (%==) SCI SCI = STrue
+      (%==) SCI SCJ = SFalse
+      (%==) SCI SCK = SFalse
+      (%==) SCI SCL = SFalse
+      (%==) SCI SCM = SFalse
+      (%==) SCI SCN = SFalse
+      (%==) SCI SCO = SFalse
+      (%==) SCI SCP = SFalse
+      (%==) SCI SCQ = SFalse
+      (%==) SCI SCR = SFalse
+      (%==) SCI SCS = SFalse
+      (%==) SCI SCT = SFalse
+      (%==) SCI SCU = SFalse
+      (%==) SCI SCV = SFalse
+      (%==) SCI SCW = SFalse
+      (%==) SCI SCX = SFalse
+      (%==) SCI SCY = SFalse
+      (%==) SCI SCZ = SFalse
+      (%==) SCJ SCA = SFalse
+      (%==) SCJ SCB = SFalse
+      (%==) SCJ SCC = SFalse
+      (%==) SCJ SCD = SFalse
+      (%==) SCJ SCE = SFalse
+      (%==) SCJ SCF = SFalse
+      (%==) SCJ SCG = SFalse
+      (%==) SCJ SCH = SFalse
+      (%==) SCJ SCI = SFalse
+      (%==) SCJ SCJ = STrue
+      (%==) SCJ SCK = SFalse
+      (%==) SCJ SCL = SFalse
+      (%==) SCJ SCM = SFalse
+      (%==) SCJ SCN = SFalse
+      (%==) SCJ SCO = SFalse
+      (%==) SCJ SCP = SFalse
+      (%==) SCJ SCQ = SFalse
+      (%==) SCJ SCR = SFalse
+      (%==) SCJ SCS = SFalse
+      (%==) SCJ SCT = SFalse
+      (%==) SCJ SCU = SFalse
+      (%==) SCJ SCV = SFalse
+      (%==) SCJ SCW = SFalse
+      (%==) SCJ SCX = SFalse
+      (%==) SCJ SCY = SFalse
+      (%==) SCJ SCZ = SFalse
+      (%==) SCK SCA = SFalse
+      (%==) SCK SCB = SFalse
+      (%==) SCK SCC = SFalse
+      (%==) SCK SCD = SFalse
+      (%==) SCK SCE = SFalse
+      (%==) SCK SCF = SFalse
+      (%==) SCK SCG = SFalse
+      (%==) SCK SCH = SFalse
+      (%==) SCK SCI = SFalse
+      (%==) SCK SCJ = SFalse
+      (%==) SCK SCK = STrue
+      (%==) SCK SCL = SFalse
+      (%==) SCK SCM = SFalse
+      (%==) SCK SCN = SFalse
+      (%==) SCK SCO = SFalse
+      (%==) SCK SCP = SFalse
+      (%==) SCK SCQ = SFalse
+      (%==) SCK SCR = SFalse
+      (%==) SCK SCS = SFalse
+      (%==) SCK SCT = SFalse
+      (%==) SCK SCU = SFalse
+      (%==) SCK SCV = SFalse
+      (%==) SCK SCW = SFalse
+      (%==) SCK SCX = SFalse
+      (%==) SCK SCY = SFalse
+      (%==) SCK SCZ = SFalse
+      (%==) SCL SCA = SFalse
+      (%==) SCL SCB = SFalse
+      (%==) SCL SCC = SFalse
+      (%==) SCL SCD = SFalse
+      (%==) SCL SCE = SFalse
+      (%==) SCL SCF = SFalse
+      (%==) SCL SCG = SFalse
+      (%==) SCL SCH = SFalse
+      (%==) SCL SCI = SFalse
+      (%==) SCL SCJ = SFalse
+      (%==) SCL SCK = SFalse
+      (%==) SCL SCL = STrue
+      (%==) SCL SCM = SFalse
+      (%==) SCL SCN = SFalse
+      (%==) SCL SCO = SFalse
+      (%==) SCL SCP = SFalse
+      (%==) SCL SCQ = SFalse
+      (%==) SCL SCR = SFalse
+      (%==) SCL SCS = SFalse
+      (%==) SCL SCT = SFalse
+      (%==) SCL SCU = SFalse
+      (%==) SCL SCV = SFalse
+      (%==) SCL SCW = SFalse
+      (%==) SCL SCX = SFalse
+      (%==) SCL SCY = SFalse
+      (%==) SCL SCZ = SFalse
+      (%==) SCM SCA = SFalse
+      (%==) SCM SCB = SFalse
+      (%==) SCM SCC = SFalse
+      (%==) SCM SCD = SFalse
+      (%==) SCM SCE = SFalse
+      (%==) SCM SCF = SFalse
+      (%==) SCM SCG = SFalse
+      (%==) SCM SCH = SFalse
+      (%==) SCM SCI = SFalse
+      (%==) SCM SCJ = SFalse
+      (%==) SCM SCK = SFalse
+      (%==) SCM SCL = SFalse
+      (%==) SCM SCM = STrue
+      (%==) SCM SCN = SFalse
+      (%==) SCM SCO = SFalse
+      (%==) SCM SCP = SFalse
+      (%==) SCM SCQ = SFalse
+      (%==) SCM SCR = SFalse
+      (%==) SCM SCS = SFalse
+      (%==) SCM SCT = SFalse
+      (%==) SCM SCU = SFalse
+      (%==) SCM SCV = SFalse
+      (%==) SCM SCW = SFalse
+      (%==) SCM SCX = SFalse
+      (%==) SCM SCY = SFalse
+      (%==) SCM SCZ = SFalse
+      (%==) SCN SCA = SFalse
+      (%==) SCN SCB = SFalse
+      (%==) SCN SCC = SFalse
+      (%==) SCN SCD = SFalse
+      (%==) SCN SCE = SFalse
+      (%==) SCN SCF = SFalse
+      (%==) SCN SCG = SFalse
+      (%==) SCN SCH = SFalse
+      (%==) SCN SCI = SFalse
+      (%==) SCN SCJ = SFalse
+      (%==) SCN SCK = SFalse
+      (%==) SCN SCL = SFalse
+      (%==) SCN SCM = SFalse
+      (%==) SCN SCN = STrue
+      (%==) SCN SCO = SFalse
+      (%==) SCN SCP = SFalse
+      (%==) SCN SCQ = SFalse
+      (%==) SCN SCR = SFalse
+      (%==) SCN SCS = SFalse
+      (%==) SCN SCT = SFalse
+      (%==) SCN SCU = SFalse
+      (%==) SCN SCV = SFalse
+      (%==) SCN SCW = SFalse
+      (%==) SCN SCX = SFalse
+      (%==) SCN SCY = SFalse
+      (%==) SCN SCZ = SFalse
+      (%==) SCO SCA = SFalse
+      (%==) SCO SCB = SFalse
+      (%==) SCO SCC = SFalse
+      (%==) SCO SCD = SFalse
+      (%==) SCO SCE = SFalse
+      (%==) SCO SCF = SFalse
+      (%==) SCO SCG = SFalse
+      (%==) SCO SCH = SFalse
+      (%==) SCO SCI = SFalse
+      (%==) SCO SCJ = SFalse
+      (%==) SCO SCK = SFalse
+      (%==) SCO SCL = SFalse
+      (%==) SCO SCM = SFalse
+      (%==) SCO SCN = SFalse
+      (%==) SCO SCO = STrue
+      (%==) SCO SCP = SFalse
+      (%==) SCO SCQ = SFalse
+      (%==) SCO SCR = SFalse
+      (%==) SCO SCS = SFalse
+      (%==) SCO SCT = SFalse
+      (%==) SCO SCU = SFalse
+      (%==) SCO SCV = SFalse
+      (%==) SCO SCW = SFalse
+      (%==) SCO SCX = SFalse
+      (%==) SCO SCY = SFalse
+      (%==) SCO SCZ = SFalse
+      (%==) SCP SCA = SFalse
+      (%==) SCP SCB = SFalse
+      (%==) SCP SCC = SFalse
+      (%==) SCP SCD = SFalse
+      (%==) SCP SCE = SFalse
+      (%==) SCP SCF = SFalse
+      (%==) SCP SCG = SFalse
+      (%==) SCP SCH = SFalse
+      (%==) SCP SCI = SFalse
+      (%==) SCP SCJ = SFalse
+      (%==) SCP SCK = SFalse
+      (%==) SCP SCL = SFalse
+      (%==) SCP SCM = SFalse
+      (%==) SCP SCN = SFalse
+      (%==) SCP SCO = SFalse
+      (%==) SCP SCP = STrue
+      (%==) SCP SCQ = SFalse
+      (%==) SCP SCR = SFalse
+      (%==) SCP SCS = SFalse
+      (%==) SCP SCT = SFalse
+      (%==) SCP SCU = SFalse
+      (%==) SCP SCV = SFalse
+      (%==) SCP SCW = SFalse
+      (%==) SCP SCX = SFalse
+      (%==) SCP SCY = SFalse
+      (%==) SCP SCZ = SFalse
+      (%==) SCQ SCA = SFalse
+      (%==) SCQ SCB = SFalse
+      (%==) SCQ SCC = SFalse
+      (%==) SCQ SCD = SFalse
+      (%==) SCQ SCE = SFalse
+      (%==) SCQ SCF = SFalse
+      (%==) SCQ SCG = SFalse
+      (%==) SCQ SCH = SFalse
+      (%==) SCQ SCI = SFalse
+      (%==) SCQ SCJ = SFalse
+      (%==) SCQ SCK = SFalse
+      (%==) SCQ SCL = SFalse
+      (%==) SCQ SCM = SFalse
+      (%==) SCQ SCN = SFalse
+      (%==) SCQ SCO = SFalse
+      (%==) SCQ SCP = SFalse
+      (%==) SCQ SCQ = STrue
+      (%==) SCQ SCR = SFalse
+      (%==) SCQ SCS = SFalse
+      (%==) SCQ SCT = SFalse
+      (%==) SCQ SCU = SFalse
+      (%==) SCQ SCV = SFalse
+      (%==) SCQ SCW = SFalse
+      (%==) SCQ SCX = SFalse
+      (%==) SCQ SCY = SFalse
+      (%==) SCQ SCZ = SFalse
+      (%==) SCR SCA = SFalse
+      (%==) SCR SCB = SFalse
+      (%==) SCR SCC = SFalse
+      (%==) SCR SCD = SFalse
+      (%==) SCR SCE = SFalse
+      (%==) SCR SCF = SFalse
+      (%==) SCR SCG = SFalse
+      (%==) SCR SCH = SFalse
+      (%==) SCR SCI = SFalse
+      (%==) SCR SCJ = SFalse
+      (%==) SCR SCK = SFalse
+      (%==) SCR SCL = SFalse
+      (%==) SCR SCM = SFalse
+      (%==) SCR SCN = SFalse
+      (%==) SCR SCO = SFalse
+      (%==) SCR SCP = SFalse
+      (%==) SCR SCQ = SFalse
+      (%==) SCR SCR = STrue
+      (%==) SCR SCS = SFalse
+      (%==) SCR SCT = SFalse
+      (%==) SCR SCU = SFalse
+      (%==) SCR SCV = SFalse
+      (%==) SCR SCW = SFalse
+      (%==) SCR SCX = SFalse
+      (%==) SCR SCY = SFalse
+      (%==) SCR SCZ = SFalse
+      (%==) SCS SCA = SFalse
+      (%==) SCS SCB = SFalse
+      (%==) SCS SCC = SFalse
+      (%==) SCS SCD = SFalse
+      (%==) SCS SCE = SFalse
+      (%==) SCS SCF = SFalse
+      (%==) SCS SCG = SFalse
+      (%==) SCS SCH = SFalse
+      (%==) SCS SCI = SFalse
+      (%==) SCS SCJ = SFalse
+      (%==) SCS SCK = SFalse
+      (%==) SCS SCL = SFalse
+      (%==) SCS SCM = SFalse
+      (%==) SCS SCN = SFalse
+      (%==) SCS SCO = SFalse
+      (%==) SCS SCP = SFalse
+      (%==) SCS SCQ = SFalse
+      (%==) SCS SCR = SFalse
+      (%==) SCS SCS = STrue
+      (%==) SCS SCT = SFalse
+      (%==) SCS SCU = SFalse
+      (%==) SCS SCV = SFalse
+      (%==) SCS SCW = SFalse
+      (%==) SCS SCX = SFalse
+      (%==) SCS SCY = SFalse
+      (%==) SCS SCZ = SFalse
+      (%==) SCT SCA = SFalse
+      (%==) SCT SCB = SFalse
+      (%==) SCT SCC = SFalse
+      (%==) SCT SCD = SFalse
+      (%==) SCT SCE = SFalse
+      (%==) SCT SCF = SFalse
+      (%==) SCT SCG = SFalse
+      (%==) SCT SCH = SFalse
+      (%==) SCT SCI = SFalse
+      (%==) SCT SCJ = SFalse
+      (%==) SCT SCK = SFalse
+      (%==) SCT SCL = SFalse
+      (%==) SCT SCM = SFalse
+      (%==) SCT SCN = SFalse
+      (%==) SCT SCO = SFalse
+      (%==) SCT SCP = SFalse
+      (%==) SCT SCQ = SFalse
+      (%==) SCT SCR = SFalse
+      (%==) SCT SCS = SFalse
+      (%==) SCT SCT = STrue
+      (%==) SCT SCU = SFalse
+      (%==) SCT SCV = SFalse
+      (%==) SCT SCW = SFalse
+      (%==) SCT SCX = SFalse
+      (%==) SCT SCY = SFalse
+      (%==) SCT SCZ = SFalse
+      (%==) SCU SCA = SFalse
+      (%==) SCU SCB = SFalse
+      (%==) SCU SCC = SFalse
+      (%==) SCU SCD = SFalse
+      (%==) SCU SCE = SFalse
+      (%==) SCU SCF = SFalse
+      (%==) SCU SCG = SFalse
+      (%==) SCU SCH = SFalse
+      (%==) SCU SCI = SFalse
+      (%==) SCU SCJ = SFalse
+      (%==) SCU SCK = SFalse
+      (%==) SCU SCL = SFalse
+      (%==) SCU SCM = SFalse
+      (%==) SCU SCN = SFalse
+      (%==) SCU SCO = SFalse
+      (%==) SCU SCP = SFalse
+      (%==) SCU SCQ = SFalse
+      (%==) SCU SCR = SFalse
+      (%==) SCU SCS = SFalse
+      (%==) SCU SCT = SFalse
+      (%==) SCU SCU = STrue
+      (%==) SCU SCV = SFalse
+      (%==) SCU SCW = SFalse
+      (%==) SCU SCX = SFalse
+      (%==) SCU SCY = SFalse
+      (%==) SCU SCZ = SFalse
+      (%==) SCV SCA = SFalse
+      (%==) SCV SCB = SFalse
+      (%==) SCV SCC = SFalse
+      (%==) SCV SCD = SFalse
+      (%==) SCV SCE = SFalse
+      (%==) SCV SCF = SFalse
+      (%==) SCV SCG = SFalse
+      (%==) SCV SCH = SFalse
+      (%==) SCV SCI = SFalse
+      (%==) SCV SCJ = SFalse
+      (%==) SCV SCK = SFalse
+      (%==) SCV SCL = SFalse
+      (%==) SCV SCM = SFalse
+      (%==) SCV SCN = SFalse
+      (%==) SCV SCO = SFalse
+      (%==) SCV SCP = SFalse
+      (%==) SCV SCQ = SFalse
+      (%==) SCV SCR = SFalse
+      (%==) SCV SCS = SFalse
+      (%==) SCV SCT = SFalse
+      (%==) SCV SCU = SFalse
+      (%==) SCV SCV = STrue
+      (%==) SCV SCW = SFalse
+      (%==) SCV SCX = SFalse
+      (%==) SCV SCY = SFalse
+      (%==) SCV SCZ = SFalse
+      (%==) SCW SCA = SFalse
+      (%==) SCW SCB = SFalse
+      (%==) SCW SCC = SFalse
+      (%==) SCW SCD = SFalse
+      (%==) SCW SCE = SFalse
+      (%==) SCW SCF = SFalse
+      (%==) SCW SCG = SFalse
+      (%==) SCW SCH = SFalse
+      (%==) SCW SCI = SFalse
+      (%==) SCW SCJ = SFalse
+      (%==) SCW SCK = SFalse
+      (%==) SCW SCL = SFalse
+      (%==) SCW SCM = SFalse
+      (%==) SCW SCN = SFalse
+      (%==) SCW SCO = SFalse
+      (%==) SCW SCP = SFalse
+      (%==) SCW SCQ = SFalse
+      (%==) SCW SCR = SFalse
+      (%==) SCW SCS = SFalse
+      (%==) SCW SCT = SFalse
+      (%==) SCW SCU = SFalse
+      (%==) SCW SCV = SFalse
+      (%==) SCW SCW = STrue
+      (%==) SCW SCX = SFalse
+      (%==) SCW SCY = SFalse
+      (%==) SCW SCZ = SFalse
+      (%==) SCX SCA = SFalse
+      (%==) SCX SCB = SFalse
+      (%==) SCX SCC = SFalse
+      (%==) SCX SCD = SFalse
+      (%==) SCX SCE = SFalse
+      (%==) SCX SCF = SFalse
+      (%==) SCX SCG = SFalse
+      (%==) SCX SCH = SFalse
+      (%==) SCX SCI = SFalse
+      (%==) SCX SCJ = SFalse
+      (%==) SCX SCK = SFalse
+      (%==) SCX SCL = SFalse
+      (%==) SCX SCM = SFalse
+      (%==) SCX SCN = SFalse
+      (%==) SCX SCO = SFalse
+      (%==) SCX SCP = SFalse
+      (%==) SCX SCQ = SFalse
+      (%==) SCX SCR = SFalse
+      (%==) SCX SCS = SFalse
+      (%==) SCX SCT = SFalse
+      (%==) SCX SCU = SFalse
+      (%==) SCX SCV = SFalse
+      (%==) SCX SCW = SFalse
+      (%==) SCX SCX = STrue
+      (%==) SCX SCY = SFalse
+      (%==) SCX SCZ = SFalse
+      (%==) SCY SCA = SFalse
+      (%==) SCY SCB = SFalse
+      (%==) SCY SCC = SFalse
+      (%==) SCY SCD = SFalse
+      (%==) SCY SCE = SFalse
+      (%==) SCY SCF = SFalse
+      (%==) SCY SCG = SFalse
+      (%==) SCY SCH = SFalse
+      (%==) SCY SCI = SFalse
+      (%==) SCY SCJ = SFalse
+      (%==) SCY SCK = SFalse
+      (%==) SCY SCL = SFalse
+      (%==) SCY SCM = SFalse
+      (%==) SCY SCN = SFalse
+      (%==) SCY SCO = SFalse
+      (%==) SCY SCP = SFalse
+      (%==) SCY SCQ = SFalse
+      (%==) SCY SCR = SFalse
+      (%==) SCY SCS = SFalse
+      (%==) SCY SCT = SFalse
+      (%==) SCY SCU = SFalse
+      (%==) SCY SCV = SFalse
+      (%==) SCY SCW = SFalse
+      (%==) SCY SCX = SFalse
+      (%==) SCY SCY = STrue
+      (%==) SCY SCZ = SFalse
+      (%==) SCZ SCA = SFalse
+      (%==) SCZ SCB = SFalse
+      (%==) SCZ SCC = SFalse
+      (%==) SCZ SCD = SFalse
+      (%==) SCZ SCE = SFalse
+      (%==) SCZ SCF = SFalse
+      (%==) SCZ SCG = SFalse
+      (%==) SCZ SCH = SFalse
+      (%==) SCZ SCI = SFalse
+      (%==) SCZ SCJ = SFalse
+      (%==) SCZ SCK = SFalse
+      (%==) SCZ SCL = SFalse
+      (%==) SCZ SCM = SFalse
+      (%==) SCZ SCN = SFalse
+      (%==) SCZ SCO = SFalse
+      (%==) SCZ SCP = SFalse
+      (%==) SCZ SCQ = SFalse
+      (%==) SCZ SCR = SFalse
+      (%==) SCZ SCS = SFalse
+      (%==) SCZ SCT = SFalse
+      (%==) SCZ SCU = SFalse
+      (%==) SCZ SCV = SFalse
+      (%==) SCZ SCW = SFalse
+      (%==) SCZ SCX = SFalse
+      (%==) SCZ SCY = SFalse
+      (%==) SCZ SCZ = STrue
+    instance (SDecide U, SDecide Nat) => SDecide U where
+      (%~) SBOOL SBOOL = Proved Refl
+      (%~) SBOOL SSTRING = Disproved (\case)
+      (%~) SBOOL SNAT = Disproved (\case)
+      (%~) SBOOL (SVEC _ _) = Disproved (\case)
+      (%~) SSTRING SBOOL = Disproved (\case)
+      (%~) SSTRING SSTRING = Proved Refl
+      (%~) SSTRING SNAT = Disproved (\case)
+      (%~) SSTRING (SVEC _ _) = Disproved (\case)
+      (%~) SNAT SBOOL = Disproved (\case)
+      (%~) SNAT SSTRING = Disproved (\case)
+      (%~) SNAT SNAT = Proved Refl
+      (%~) SNAT (SVEC _ _) = Disproved (\case)
+      (%~) (SVEC _ _) SBOOL = Disproved (\case)
+      (%~) (SVEC _ _) SSTRING = Disproved (\case)
+      (%~) (SVEC _ _) SNAT = Disproved (\case)
+      (%~) (SVEC a a) (SVEC b b)
+        = (\cases
+             (Proved Refl) (Proved Refl) -> Proved Refl
+             (Disproved contra) _ -> Disproved (\cases Refl -> contra Refl)
+             _ (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b) ((%~) a b)
+    instance Eq (SU (z :: U)) where
+      (==) _ _ = True
+    instance (SDecide U, SDecide Nat) =>
+             GHC.Internal.Data.Type.Equality.TestEquality (SU :: U
+                                                                 -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
+        = Data.Singletons.Decide.decideEquality
+    instance (SDecide U, SDecide Nat) =>
+             GHC.Internal.Data.Type.Coercion.TestCoercion (SU :: U
+                                                                 -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
+        = Data.Singletons.Decide.decideCoercion
+    instance SDecide AChar where
+      (%~) SCA SCA = Proved Refl
+      (%~) SCA SCB = Disproved (\case)
+      (%~) SCA SCC = Disproved (\case)
+      (%~) SCA SCD = Disproved (\case)
+      (%~) SCA SCE = Disproved (\case)
+      (%~) SCA SCF = Disproved (\case)
+      (%~) SCA SCG = Disproved (\case)
+      (%~) SCA SCH = Disproved (\case)
+      (%~) SCA SCI = Disproved (\case)
+      (%~) SCA SCJ = Disproved (\case)
+      (%~) SCA SCK = Disproved (\case)
+      (%~) SCA SCL = Disproved (\case)
+      (%~) SCA SCM = Disproved (\case)
+      (%~) SCA SCN = Disproved (\case)
+      (%~) SCA SCO = Disproved (\case)
+      (%~) SCA SCP = Disproved (\case)
+      (%~) SCA SCQ = Disproved (\case)
+      (%~) SCA SCR = Disproved (\case)
+      (%~) SCA SCS = Disproved (\case)
+      (%~) SCA SCT = Disproved (\case)
+      (%~) SCA SCU = Disproved (\case)
+      (%~) SCA SCV = Disproved (\case)
+      (%~) SCA SCW = Disproved (\case)
+      (%~) SCA SCX = Disproved (\case)
+      (%~) SCA SCY = Disproved (\case)
+      (%~) SCA SCZ = Disproved (\case)
+      (%~) SCB SCA = Disproved (\case)
+      (%~) SCB SCB = Proved Refl
+      (%~) SCB SCC = Disproved (\case)
+      (%~) SCB SCD = Disproved (\case)
+      (%~) SCB SCE = Disproved (\case)
+      (%~) SCB SCF = Disproved (\case)
+      (%~) SCB SCG = Disproved (\case)
+      (%~) SCB SCH = Disproved (\case)
+      (%~) SCB SCI = Disproved (\case)
+      (%~) SCB SCJ = Disproved (\case)
+      (%~) SCB SCK = Disproved (\case)
+      (%~) SCB SCL = Disproved (\case)
+      (%~) SCB SCM = Disproved (\case)
+      (%~) SCB SCN = Disproved (\case)
+      (%~) SCB SCO = Disproved (\case)
+      (%~) SCB SCP = Disproved (\case)
+      (%~) SCB SCQ = Disproved (\case)
+      (%~) SCB SCR = Disproved (\case)
+      (%~) SCB SCS = Disproved (\case)
+      (%~) SCB SCT = Disproved (\case)
+      (%~) SCB SCU = Disproved (\case)
+      (%~) SCB SCV = Disproved (\case)
+      (%~) SCB SCW = Disproved (\case)
+      (%~) SCB SCX = Disproved (\case)
+      (%~) SCB SCY = Disproved (\case)
+      (%~) SCB SCZ = Disproved (\case)
+      (%~) SCC SCA = Disproved (\case)
+      (%~) SCC SCB = Disproved (\case)
+      (%~) SCC SCC = Proved Refl
+      (%~) SCC SCD = Disproved (\case)
+      (%~) SCC SCE = Disproved (\case)
+      (%~) SCC SCF = Disproved (\case)
+      (%~) SCC SCG = Disproved (\case)
+      (%~) SCC SCH = Disproved (\case)
+      (%~) SCC SCI = Disproved (\case)
+      (%~) SCC SCJ = Disproved (\case)
+      (%~) SCC SCK = Disproved (\case)
+      (%~) SCC SCL = Disproved (\case)
+      (%~) SCC SCM = Disproved (\case)
+      (%~) SCC SCN = Disproved (\case)
+      (%~) SCC SCO = Disproved (\case)
+      (%~) SCC SCP = Disproved (\case)
+      (%~) SCC SCQ = Disproved (\case)
+      (%~) SCC SCR = Disproved (\case)
+      (%~) SCC SCS = Disproved (\case)
+      (%~) SCC SCT = Disproved (\case)
+      (%~) SCC SCU = Disproved (\case)
+      (%~) SCC SCV = Disproved (\case)
+      (%~) SCC SCW = Disproved (\case)
+      (%~) SCC SCX = Disproved (\case)
+      (%~) SCC SCY = Disproved (\case)
+      (%~) SCC SCZ = Disproved (\case)
+      (%~) SCD SCA = Disproved (\case)
+      (%~) SCD SCB = Disproved (\case)
+      (%~) SCD SCC = Disproved (\case)
+      (%~) SCD SCD = Proved Refl
+      (%~) SCD SCE = Disproved (\case)
+      (%~) SCD SCF = Disproved (\case)
+      (%~) SCD SCG = Disproved (\case)
+      (%~) SCD SCH = Disproved (\case)
+      (%~) SCD SCI = Disproved (\case)
+      (%~) SCD SCJ = Disproved (\case)
+      (%~) SCD SCK = Disproved (\case)
+      (%~) SCD SCL = Disproved (\case)
+      (%~) SCD SCM = Disproved (\case)
+      (%~) SCD SCN = Disproved (\case)
+      (%~) SCD SCO = Disproved (\case)
+      (%~) SCD SCP = Disproved (\case)
+      (%~) SCD SCQ = Disproved (\case)
+      (%~) SCD SCR = Disproved (\case)
+      (%~) SCD SCS = Disproved (\case)
+      (%~) SCD SCT = Disproved (\case)
+      (%~) SCD SCU = Disproved (\case)
+      (%~) SCD SCV = Disproved (\case)
+      (%~) SCD SCW = Disproved (\case)
+      (%~) SCD SCX = Disproved (\case)
+      (%~) SCD SCY = Disproved (\case)
+      (%~) SCD SCZ = Disproved (\case)
+      (%~) SCE SCA = Disproved (\case)
+      (%~) SCE SCB = Disproved (\case)
+      (%~) SCE SCC = Disproved (\case)
+      (%~) SCE SCD = Disproved (\case)
+      (%~) SCE SCE = Proved Refl
+      (%~) SCE SCF = Disproved (\case)
+      (%~) SCE SCG = Disproved (\case)
+      (%~) SCE SCH = Disproved (\case)
+      (%~) SCE SCI = Disproved (\case)
+      (%~) SCE SCJ = Disproved (\case)
+      (%~) SCE SCK = Disproved (\case)
+      (%~) SCE SCL = Disproved (\case)
+      (%~) SCE SCM = Disproved (\case)
+      (%~) SCE SCN = Disproved (\case)
+      (%~) SCE SCO = Disproved (\case)
+      (%~) SCE SCP = Disproved (\case)
+      (%~) SCE SCQ = Disproved (\case)
+      (%~) SCE SCR = Disproved (\case)
+      (%~) SCE SCS = Disproved (\case)
+      (%~) SCE SCT = Disproved (\case)
+      (%~) SCE SCU = Disproved (\case)
+      (%~) SCE SCV = Disproved (\case)
+      (%~) SCE SCW = Disproved (\case)
+      (%~) SCE SCX = Disproved (\case)
+      (%~) SCE SCY = Disproved (\case)
+      (%~) SCE SCZ = Disproved (\case)
+      (%~) SCF SCA = Disproved (\case)
+      (%~) SCF SCB = Disproved (\case)
+      (%~) SCF SCC = Disproved (\case)
+      (%~) SCF SCD = Disproved (\case)
+      (%~) SCF SCE = Disproved (\case)
+      (%~) SCF SCF = Proved Refl
+      (%~) SCF SCG = Disproved (\case)
+      (%~) SCF SCH = Disproved (\case)
+      (%~) SCF SCI = Disproved (\case)
+      (%~) SCF SCJ = Disproved (\case)
+      (%~) SCF SCK = Disproved (\case)
+      (%~) SCF SCL = Disproved (\case)
+      (%~) SCF SCM = Disproved (\case)
+      (%~) SCF SCN = Disproved (\case)
+      (%~) SCF SCO = Disproved (\case)
+      (%~) SCF SCP = Disproved (\case)
+      (%~) SCF SCQ = Disproved (\case)
+      (%~) SCF SCR = Disproved (\case)
+      (%~) SCF SCS = Disproved (\case)
+      (%~) SCF SCT = Disproved (\case)
+      (%~) SCF SCU = Disproved (\case)
+      (%~) SCF SCV = Disproved (\case)
+      (%~) SCF SCW = Disproved (\case)
+      (%~) SCF SCX = Disproved (\case)
+      (%~) SCF SCY = Disproved (\case)
+      (%~) SCF SCZ = Disproved (\case)
+      (%~) SCG SCA = Disproved (\case)
+      (%~) SCG SCB = Disproved (\case)
+      (%~) SCG SCC = Disproved (\case)
+      (%~) SCG SCD = Disproved (\case)
+      (%~) SCG SCE = Disproved (\case)
+      (%~) SCG SCF = Disproved (\case)
+      (%~) SCG SCG = Proved Refl
+      (%~) SCG SCH = Disproved (\case)
+      (%~) SCG SCI = Disproved (\case)
+      (%~) SCG SCJ = Disproved (\case)
+      (%~) SCG SCK = Disproved (\case)
+      (%~) SCG SCL = Disproved (\case)
+      (%~) SCG SCM = Disproved (\case)
+      (%~) SCG SCN = Disproved (\case)
+      (%~) SCG SCO = Disproved (\case)
+      (%~) SCG SCP = Disproved (\case)
+      (%~) SCG SCQ = Disproved (\case)
+      (%~) SCG SCR = Disproved (\case)
+      (%~) SCG SCS = Disproved (\case)
+      (%~) SCG SCT = Disproved (\case)
+      (%~) SCG SCU = Disproved (\case)
+      (%~) SCG SCV = Disproved (\case)
+      (%~) SCG SCW = Disproved (\case)
+      (%~) SCG SCX = Disproved (\case)
+      (%~) SCG SCY = Disproved (\case)
+      (%~) SCG SCZ = Disproved (\case)
+      (%~) SCH SCA = Disproved (\case)
+      (%~) SCH SCB = Disproved (\case)
+      (%~) SCH SCC = Disproved (\case)
+      (%~) SCH SCD = Disproved (\case)
+      (%~) SCH SCE = Disproved (\case)
+      (%~) SCH SCF = Disproved (\case)
+      (%~) SCH SCG = Disproved (\case)
+      (%~) SCH SCH = Proved Refl
+      (%~) SCH SCI = Disproved (\case)
+      (%~) SCH SCJ = Disproved (\case)
+      (%~) SCH SCK = Disproved (\case)
+      (%~) SCH SCL = Disproved (\case)
+      (%~) SCH SCM = Disproved (\case)
+      (%~) SCH SCN = Disproved (\case)
+      (%~) SCH SCO = Disproved (\case)
+      (%~) SCH SCP = Disproved (\case)
+      (%~) SCH SCQ = Disproved (\case)
+      (%~) SCH SCR = Disproved (\case)
+      (%~) SCH SCS = Disproved (\case)
+      (%~) SCH SCT = Disproved (\case)
+      (%~) SCH SCU = Disproved (\case)
+      (%~) SCH SCV = Disproved (\case)
+      (%~) SCH SCW = Disproved (\case)
+      (%~) SCH SCX = Disproved (\case)
+      (%~) SCH SCY = Disproved (\case)
+      (%~) SCH SCZ = Disproved (\case)
+      (%~) SCI SCA = Disproved (\case)
+      (%~) SCI SCB = Disproved (\case)
+      (%~) SCI SCC = Disproved (\case)
+      (%~) SCI SCD = Disproved (\case)
+      (%~) SCI SCE = Disproved (\case)
+      (%~) SCI SCF = Disproved (\case)
+      (%~) SCI SCG = Disproved (\case)
+      (%~) SCI SCH = Disproved (\case)
+      (%~) SCI SCI = Proved Refl
+      (%~) SCI SCJ = Disproved (\case)
+      (%~) SCI SCK = Disproved (\case)
+      (%~) SCI SCL = Disproved (\case)
+      (%~) SCI SCM = Disproved (\case)
+      (%~) SCI SCN = Disproved (\case)
+      (%~) SCI SCO = Disproved (\case)
+      (%~) SCI SCP = Disproved (\case)
+      (%~) SCI SCQ = Disproved (\case)
+      (%~) SCI SCR = Disproved (\case)
+      (%~) SCI SCS = Disproved (\case)
+      (%~) SCI SCT = Disproved (\case)
+      (%~) SCI SCU = Disproved (\case)
+      (%~) SCI SCV = Disproved (\case)
+      (%~) SCI SCW = Disproved (\case)
+      (%~) SCI SCX = Disproved (\case)
+      (%~) SCI SCY = Disproved (\case)
+      (%~) SCI SCZ = Disproved (\case)
+      (%~) SCJ SCA = Disproved (\case)
+      (%~) SCJ SCB = Disproved (\case)
+      (%~) SCJ SCC = Disproved (\case)
+      (%~) SCJ SCD = Disproved (\case)
+      (%~) SCJ SCE = Disproved (\case)
+      (%~) SCJ SCF = Disproved (\case)
+      (%~) SCJ SCG = Disproved (\case)
+      (%~) SCJ SCH = Disproved (\case)
+      (%~) SCJ SCI = Disproved (\case)
+      (%~) SCJ SCJ = Proved Refl
+      (%~) SCJ SCK = Disproved (\case)
+      (%~) SCJ SCL = Disproved (\case)
+      (%~) SCJ SCM = Disproved (\case)
+      (%~) SCJ SCN = Disproved (\case)
+      (%~) SCJ SCO = Disproved (\case)
+      (%~) SCJ SCP = Disproved (\case)
+      (%~) SCJ SCQ = Disproved (\case)
+      (%~) SCJ SCR = Disproved (\case)
+      (%~) SCJ SCS = Disproved (\case)
+      (%~) SCJ SCT = Disproved (\case)
+      (%~) SCJ SCU = Disproved (\case)
+      (%~) SCJ SCV = Disproved (\case)
+      (%~) SCJ SCW = Disproved (\case)
+      (%~) SCJ SCX = Disproved (\case)
+      (%~) SCJ SCY = Disproved (\case)
+      (%~) SCJ SCZ = Disproved (\case)
+      (%~) SCK SCA = Disproved (\case)
+      (%~) SCK SCB = Disproved (\case)
+      (%~) SCK SCC = Disproved (\case)
+      (%~) SCK SCD = Disproved (\case)
+      (%~) SCK SCE = Disproved (\case)
+      (%~) SCK SCF = Disproved (\case)
+      (%~) SCK SCG = Disproved (\case)
+      (%~) SCK SCH = Disproved (\case)
+      (%~) SCK SCI = Disproved (\case)
+      (%~) SCK SCJ = Disproved (\case)
+      (%~) SCK SCK = Proved Refl
+      (%~) SCK SCL = Disproved (\case)
+      (%~) SCK SCM = Disproved (\case)
+      (%~) SCK SCN = Disproved (\case)
+      (%~) SCK SCO = Disproved (\case)
+      (%~) SCK SCP = Disproved (\case)
+      (%~) SCK SCQ = Disproved (\case)
+      (%~) SCK SCR = Disproved (\case)
+      (%~) SCK SCS = Disproved (\case)
+      (%~) SCK SCT = Disproved (\case)
+      (%~) SCK SCU = Disproved (\case)
+      (%~) SCK SCV = Disproved (\case)
+      (%~) SCK SCW = Disproved (\case)
+      (%~) SCK SCX = Disproved (\case)
+      (%~) SCK SCY = Disproved (\case)
+      (%~) SCK SCZ = Disproved (\case)
+      (%~) SCL SCA = Disproved (\case)
+      (%~) SCL SCB = Disproved (\case)
+      (%~) SCL SCC = Disproved (\case)
+      (%~) SCL SCD = Disproved (\case)
+      (%~) SCL SCE = Disproved (\case)
+      (%~) SCL SCF = Disproved (\case)
+      (%~) SCL SCG = Disproved (\case)
+      (%~) SCL SCH = Disproved (\case)
+      (%~) SCL SCI = Disproved (\case)
+      (%~) SCL SCJ = Disproved (\case)
+      (%~) SCL SCK = Disproved (\case)
+      (%~) SCL SCL = Proved Refl
+      (%~) SCL SCM = Disproved (\case)
+      (%~) SCL SCN = Disproved (\case)
+      (%~) SCL SCO = Disproved (\case)
+      (%~) SCL SCP = Disproved (\case)
+      (%~) SCL SCQ = Disproved (\case)
+      (%~) SCL SCR = Disproved (\case)
+      (%~) SCL SCS = Disproved (\case)
+      (%~) SCL SCT = Disproved (\case)
+      (%~) SCL SCU = Disproved (\case)
+      (%~) SCL SCV = Disproved (\case)
+      (%~) SCL SCW = Disproved (\case)
+      (%~) SCL SCX = Disproved (\case)
+      (%~) SCL SCY = Disproved (\case)
+      (%~) SCL SCZ = Disproved (\case)
+      (%~) SCM SCA = Disproved (\case)
+      (%~) SCM SCB = Disproved (\case)
+      (%~) SCM SCC = Disproved (\case)
+      (%~) SCM SCD = Disproved (\case)
+      (%~) SCM SCE = Disproved (\case)
+      (%~) SCM SCF = Disproved (\case)
+      (%~) SCM SCG = Disproved (\case)
+      (%~) SCM SCH = Disproved (\case)
+      (%~) SCM SCI = Disproved (\case)
+      (%~) SCM SCJ = Disproved (\case)
+      (%~) SCM SCK = Disproved (\case)
+      (%~) SCM SCL = Disproved (\case)
+      (%~) SCM SCM = Proved Refl
+      (%~) SCM SCN = Disproved (\case)
+      (%~) SCM SCO = Disproved (\case)
+      (%~) SCM SCP = Disproved (\case)
+      (%~) SCM SCQ = Disproved (\case)
+      (%~) SCM SCR = Disproved (\case)
+      (%~) SCM SCS = Disproved (\case)
+      (%~) SCM SCT = Disproved (\case)
+      (%~) SCM SCU = Disproved (\case)
+      (%~) SCM SCV = Disproved (\case)
+      (%~) SCM SCW = Disproved (\case)
+      (%~) SCM SCX = Disproved (\case)
+      (%~) SCM SCY = Disproved (\case)
+      (%~) SCM SCZ = Disproved (\case)
+      (%~) SCN SCA = Disproved (\case)
+      (%~) SCN SCB = Disproved (\case)
+      (%~) SCN SCC = Disproved (\case)
+      (%~) SCN SCD = Disproved (\case)
+      (%~) SCN SCE = Disproved (\case)
+      (%~) SCN SCF = Disproved (\case)
+      (%~) SCN SCG = Disproved (\case)
+      (%~) SCN SCH = Disproved (\case)
+      (%~) SCN SCI = Disproved (\case)
+      (%~) SCN SCJ = Disproved (\case)
+      (%~) SCN SCK = Disproved (\case)
+      (%~) SCN SCL = Disproved (\case)
+      (%~) SCN SCM = Disproved (\case)
+      (%~) SCN SCN = Proved Refl
+      (%~) SCN SCO = Disproved (\case)
+      (%~) SCN SCP = Disproved (\case)
+      (%~) SCN SCQ = Disproved (\case)
+      (%~) SCN SCR = Disproved (\case)
+      (%~) SCN SCS = Disproved (\case)
+      (%~) SCN SCT = Disproved (\case)
+      (%~) SCN SCU = Disproved (\case)
+      (%~) SCN SCV = Disproved (\case)
+      (%~) SCN SCW = Disproved (\case)
+      (%~) SCN SCX = Disproved (\case)
+      (%~) SCN SCY = Disproved (\case)
+      (%~) SCN SCZ = Disproved (\case)
+      (%~) SCO SCA = Disproved (\case)
+      (%~) SCO SCB = Disproved (\case)
+      (%~) SCO SCC = Disproved (\case)
+      (%~) SCO SCD = Disproved (\case)
+      (%~) SCO SCE = Disproved (\case)
+      (%~) SCO SCF = Disproved (\case)
+      (%~) SCO SCG = Disproved (\case)
+      (%~) SCO SCH = Disproved (\case)
+      (%~) SCO SCI = Disproved (\case)
+      (%~) SCO SCJ = Disproved (\case)
+      (%~) SCO SCK = Disproved (\case)
+      (%~) SCO SCL = Disproved (\case)
+      (%~) SCO SCM = Disproved (\case)
+      (%~) SCO SCN = Disproved (\case)
+      (%~) SCO SCO = Proved Refl
+      (%~) SCO SCP = Disproved (\case)
+      (%~) SCO SCQ = Disproved (\case)
+      (%~) SCO SCR = Disproved (\case)
+      (%~) SCO SCS = Disproved (\case)
+      (%~) SCO SCT = Disproved (\case)
+      (%~) SCO SCU = Disproved (\case)
+      (%~) SCO SCV = Disproved (\case)
+      (%~) SCO SCW = Disproved (\case)
+      (%~) SCO SCX = Disproved (\case)
+      (%~) SCO SCY = Disproved (\case)
+      (%~) SCO SCZ = Disproved (\case)
+      (%~) SCP SCA = Disproved (\case)
+      (%~) SCP SCB = Disproved (\case)
+      (%~) SCP SCC = Disproved (\case)
+      (%~) SCP SCD = Disproved (\case)
+      (%~) SCP SCE = Disproved (\case)
+      (%~) SCP SCF = Disproved (\case)
+      (%~) SCP SCG = Disproved (\case)
+      (%~) SCP SCH = Disproved (\case)
+      (%~) SCP SCI = Disproved (\case)
+      (%~) SCP SCJ = Disproved (\case)
+      (%~) SCP SCK = Disproved (\case)
+      (%~) SCP SCL = Disproved (\case)
+      (%~) SCP SCM = Disproved (\case)
+      (%~) SCP SCN = Disproved (\case)
+      (%~) SCP SCO = Disproved (\case)
+      (%~) SCP SCP = Proved Refl
+      (%~) SCP SCQ = Disproved (\case)
+      (%~) SCP SCR = Disproved (\case)
+      (%~) SCP SCS = Disproved (\case)
+      (%~) SCP SCT = Disproved (\case)
+      (%~) SCP SCU = Disproved (\case)
+      (%~) SCP SCV = Disproved (\case)
+      (%~) SCP SCW = Disproved (\case)
+      (%~) SCP SCX = Disproved (\case)
+      (%~) SCP SCY = Disproved (\case)
+      (%~) SCP SCZ = Disproved (\case)
+      (%~) SCQ SCA = Disproved (\case)
+      (%~) SCQ SCB = Disproved (\case)
+      (%~) SCQ SCC = Disproved (\case)
+      (%~) SCQ SCD = Disproved (\case)
+      (%~) SCQ SCE = Disproved (\case)
+      (%~) SCQ SCF = Disproved (\case)
+      (%~) SCQ SCG = Disproved (\case)
+      (%~) SCQ SCH = Disproved (\case)
+      (%~) SCQ SCI = Disproved (\case)
+      (%~) SCQ SCJ = Disproved (\case)
+      (%~) SCQ SCK = Disproved (\case)
+      (%~) SCQ SCL = Disproved (\case)
+      (%~) SCQ SCM = Disproved (\case)
+      (%~) SCQ SCN = Disproved (\case)
+      (%~) SCQ SCO = Disproved (\case)
+      (%~) SCQ SCP = Disproved (\case)
+      (%~) SCQ SCQ = Proved Refl
+      (%~) SCQ SCR = Disproved (\case)
+      (%~) SCQ SCS = Disproved (\case)
+      (%~) SCQ SCT = Disproved (\case)
+      (%~) SCQ SCU = Disproved (\case)
+      (%~) SCQ SCV = Disproved (\case)
+      (%~) SCQ SCW = Disproved (\case)
+      (%~) SCQ SCX = Disproved (\case)
+      (%~) SCQ SCY = Disproved (\case)
+      (%~) SCQ SCZ = Disproved (\case)
+      (%~) SCR SCA = Disproved (\case)
+      (%~) SCR SCB = Disproved (\case)
+      (%~) SCR SCC = Disproved (\case)
+      (%~) SCR SCD = Disproved (\case)
+      (%~) SCR SCE = Disproved (\case)
+      (%~) SCR SCF = Disproved (\case)
+      (%~) SCR SCG = Disproved (\case)
+      (%~) SCR SCH = Disproved (\case)
+      (%~) SCR SCI = Disproved (\case)
+      (%~) SCR SCJ = Disproved (\case)
+      (%~) SCR SCK = Disproved (\case)
+      (%~) SCR SCL = Disproved (\case)
+      (%~) SCR SCM = Disproved (\case)
+      (%~) SCR SCN = Disproved (\case)
+      (%~) SCR SCO = Disproved (\case)
+      (%~) SCR SCP = Disproved (\case)
+      (%~) SCR SCQ = Disproved (\case)
+      (%~) SCR SCR = Proved Refl
+      (%~) SCR SCS = Disproved (\case)
+      (%~) SCR SCT = Disproved (\case)
+      (%~) SCR SCU = Disproved (\case)
+      (%~) SCR SCV = Disproved (\case)
+      (%~) SCR SCW = Disproved (\case)
+      (%~) SCR SCX = Disproved (\case)
+      (%~) SCR SCY = Disproved (\case)
+      (%~) SCR SCZ = Disproved (\case)
+      (%~) SCS SCA = Disproved (\case)
+      (%~) SCS SCB = Disproved (\case)
+      (%~) SCS SCC = Disproved (\case)
+      (%~) SCS SCD = Disproved (\case)
+      (%~) SCS SCE = Disproved (\case)
+      (%~) SCS SCF = Disproved (\case)
+      (%~) SCS SCG = Disproved (\case)
+      (%~) SCS SCH = Disproved (\case)
+      (%~) SCS SCI = Disproved (\case)
+      (%~) SCS SCJ = Disproved (\case)
+      (%~) SCS SCK = Disproved (\case)
+      (%~) SCS SCL = Disproved (\case)
+      (%~) SCS SCM = Disproved (\case)
+      (%~) SCS SCN = Disproved (\case)
+      (%~) SCS SCO = Disproved (\case)
+      (%~) SCS SCP = Disproved (\case)
+      (%~) SCS SCQ = Disproved (\case)
+      (%~) SCS SCR = Disproved (\case)
+      (%~) SCS SCS = Proved Refl
+      (%~) SCS SCT = Disproved (\case)
+      (%~) SCS SCU = Disproved (\case)
+      (%~) SCS SCV = Disproved (\case)
+      (%~) SCS SCW = Disproved (\case)
+      (%~) SCS SCX = Disproved (\case)
+      (%~) SCS SCY = Disproved (\case)
+      (%~) SCS SCZ = Disproved (\case)
+      (%~) SCT SCA = Disproved (\case)
+      (%~) SCT SCB = Disproved (\case)
+      (%~) SCT SCC = Disproved (\case)
+      (%~) SCT SCD = Disproved (\case)
+      (%~) SCT SCE = Disproved (\case)
+      (%~) SCT SCF = Disproved (\case)
+      (%~) SCT SCG = Disproved (\case)
+      (%~) SCT SCH = Disproved (\case)
+      (%~) SCT SCI = Disproved (\case)
+      (%~) SCT SCJ = Disproved (\case)
+      (%~) SCT SCK = Disproved (\case)
+      (%~) SCT SCL = Disproved (\case)
+      (%~) SCT SCM = Disproved (\case)
+      (%~) SCT SCN = Disproved (\case)
+      (%~) SCT SCO = Disproved (\case)
+      (%~) SCT SCP = Disproved (\case)
+      (%~) SCT SCQ = Disproved (\case)
+      (%~) SCT SCR = Disproved (\case)
+      (%~) SCT SCS = Disproved (\case)
+      (%~) SCT SCT = Proved Refl
+      (%~) SCT SCU = Disproved (\case)
+      (%~) SCT SCV = Disproved (\case)
+      (%~) SCT SCW = Disproved (\case)
+      (%~) SCT SCX = Disproved (\case)
+      (%~) SCT SCY = Disproved (\case)
+      (%~) SCT SCZ = Disproved (\case)
+      (%~) SCU SCA = Disproved (\case)
+      (%~) SCU SCB = Disproved (\case)
+      (%~) SCU SCC = Disproved (\case)
+      (%~) SCU SCD = Disproved (\case)
+      (%~) SCU SCE = Disproved (\case)
+      (%~) SCU SCF = Disproved (\case)
+      (%~) SCU SCG = Disproved (\case)
+      (%~) SCU SCH = Disproved (\case)
+      (%~) SCU SCI = Disproved (\case)
+      (%~) SCU SCJ = Disproved (\case)
+      (%~) SCU SCK = Disproved (\case)
+      (%~) SCU SCL = Disproved (\case)
+      (%~) SCU SCM = Disproved (\case)
+      (%~) SCU SCN = Disproved (\case)
+      (%~) SCU SCO = Disproved (\case)
+      (%~) SCU SCP = Disproved (\case)
+      (%~) SCU SCQ = Disproved (\case)
+      (%~) SCU SCR = Disproved (\case)
+      (%~) SCU SCS = Disproved (\case)
+      (%~) SCU SCT = Disproved (\case)
+      (%~) SCU SCU = Proved Refl
+      (%~) SCU SCV = Disproved (\case)
+      (%~) SCU SCW = Disproved (\case)
+      (%~) SCU SCX = Disproved (\case)
+      (%~) SCU SCY = Disproved (\case)
+      (%~) SCU SCZ = Disproved (\case)
+      (%~) SCV SCA = Disproved (\case)
+      (%~) SCV SCB = Disproved (\case)
+      (%~) SCV SCC = Disproved (\case)
+      (%~) SCV SCD = Disproved (\case)
+      (%~) SCV SCE = Disproved (\case)
+      (%~) SCV SCF = Disproved (\case)
+      (%~) SCV SCG = Disproved (\case)
+      (%~) SCV SCH = Disproved (\case)
+      (%~) SCV SCI = Disproved (\case)
+      (%~) SCV SCJ = Disproved (\case)
+      (%~) SCV SCK = Disproved (\case)
+      (%~) SCV SCL = Disproved (\case)
+      (%~) SCV SCM = Disproved (\case)
+      (%~) SCV SCN = Disproved (\case)
+      (%~) SCV SCO = Disproved (\case)
+      (%~) SCV SCP = Disproved (\case)
+      (%~) SCV SCQ = Disproved (\case)
+      (%~) SCV SCR = Disproved (\case)
+      (%~) SCV SCS = Disproved (\case)
+      (%~) SCV SCT = Disproved (\case)
+      (%~) SCV SCU = Disproved (\case)
+      (%~) SCV SCV = Proved Refl
+      (%~) SCV SCW = Disproved (\case)
+      (%~) SCV SCX = Disproved (\case)
+      (%~) SCV SCY = Disproved (\case)
+      (%~) SCV SCZ = Disproved (\case)
+      (%~) SCW SCA = Disproved (\case)
+      (%~) SCW SCB = Disproved (\case)
+      (%~) SCW SCC = Disproved (\case)
+      (%~) SCW SCD = Disproved (\case)
+      (%~) SCW SCE = Disproved (\case)
+      (%~) SCW SCF = Disproved (\case)
+      (%~) SCW SCG = Disproved (\case)
+      (%~) SCW SCH = Disproved (\case)
+      (%~) SCW SCI = Disproved (\case)
+      (%~) SCW SCJ = Disproved (\case)
+      (%~) SCW SCK = Disproved (\case)
+      (%~) SCW SCL = Disproved (\case)
+      (%~) SCW SCM = Disproved (\case)
+      (%~) SCW SCN = Disproved (\case)
+      (%~) SCW SCO = Disproved (\case)
+      (%~) SCW SCP = Disproved (\case)
+      (%~) SCW SCQ = Disproved (\case)
+      (%~) SCW SCR = Disproved (\case)
+      (%~) SCW SCS = Disproved (\case)
+      (%~) SCW SCT = Disproved (\case)
+      (%~) SCW SCU = Disproved (\case)
+      (%~) SCW SCV = Disproved (\case)
+      (%~) SCW SCW = Proved Refl
+      (%~) SCW SCX = Disproved (\case)
+      (%~) SCW SCY = Disproved (\case)
+      (%~) SCW SCZ = Disproved (\case)
+      (%~) SCX SCA = Disproved (\case)
+      (%~) SCX SCB = Disproved (\case)
+      (%~) SCX SCC = Disproved (\case)
+      (%~) SCX SCD = Disproved (\case)
+      (%~) SCX SCE = Disproved (\case)
+      (%~) SCX SCF = Disproved (\case)
+      (%~) SCX SCG = Disproved (\case)
+      (%~) SCX SCH = Disproved (\case)
+      (%~) SCX SCI = Disproved (\case)
+      (%~) SCX SCJ = Disproved (\case)
+      (%~) SCX SCK = Disproved (\case)
+      (%~) SCX SCL = Disproved (\case)
+      (%~) SCX SCM = Disproved (\case)
+      (%~) SCX SCN = Disproved (\case)
+      (%~) SCX SCO = Disproved (\case)
+      (%~) SCX SCP = Disproved (\case)
+      (%~) SCX SCQ = Disproved (\case)
+      (%~) SCX SCR = Disproved (\case)
+      (%~) SCX SCS = Disproved (\case)
+      (%~) SCX SCT = Disproved (\case)
+      (%~) SCX SCU = Disproved (\case)
+      (%~) SCX SCV = Disproved (\case)
+      (%~) SCX SCW = Disproved (\case)
+      (%~) SCX SCX = Proved Refl
+      (%~) SCX SCY = Disproved (\case)
+      (%~) SCX SCZ = Disproved (\case)
+      (%~) SCY SCA = Disproved (\case)
+      (%~) SCY SCB = Disproved (\case)
+      (%~) SCY SCC = Disproved (\case)
+      (%~) SCY SCD = Disproved (\case)
+      (%~) SCY SCE = Disproved (\case)
+      (%~) SCY SCF = Disproved (\case)
+      (%~) SCY SCG = Disproved (\case)
+      (%~) SCY SCH = Disproved (\case)
+      (%~) SCY SCI = Disproved (\case)
+      (%~) SCY SCJ = Disproved (\case)
+      (%~) SCY SCK = Disproved (\case)
+      (%~) SCY SCL = Disproved (\case)
+      (%~) SCY SCM = Disproved (\case)
+      (%~) SCY SCN = Disproved (\case)
+      (%~) SCY SCO = Disproved (\case)
+      (%~) SCY SCP = Disproved (\case)
+      (%~) SCY SCQ = Disproved (\case)
+      (%~) SCY SCR = Disproved (\case)
+      (%~) SCY SCS = Disproved (\case)
+      (%~) SCY SCT = Disproved (\case)
+      (%~) SCY SCU = Disproved (\case)
+      (%~) SCY SCV = Disproved (\case)
+      (%~) SCY SCW = Disproved (\case)
+      (%~) SCY SCX = Disproved (\case)
+      (%~) SCY SCY = Proved Refl
+      (%~) SCY SCZ = Disproved (\case)
+      (%~) SCZ SCA = Disproved (\case)
+      (%~) SCZ SCB = Disproved (\case)
+      (%~) SCZ SCC = Disproved (\case)
+      (%~) SCZ SCD = Disproved (\case)
+      (%~) SCZ SCE = Disproved (\case)
+      (%~) SCZ SCF = Disproved (\case)
+      (%~) SCZ SCG = Disproved (\case)
+      (%~) SCZ SCH = Disproved (\case)
+      (%~) SCZ SCI = Disproved (\case)
+      (%~) SCZ SCJ = Disproved (\case)
+      (%~) SCZ SCK = Disproved (\case)
+      (%~) SCZ SCL = Disproved (\case)
+      (%~) SCZ SCM = Disproved (\case)
+      (%~) SCZ SCN = Disproved (\case)
+      (%~) SCZ SCO = Disproved (\case)
+      (%~) SCZ SCP = Disproved (\case)
+      (%~) SCZ SCQ = Disproved (\case)
+      (%~) SCZ SCR = Disproved (\case)
+      (%~) SCZ SCS = Disproved (\case)
+      (%~) SCZ SCT = Disproved (\case)
+      (%~) SCZ SCU = Disproved (\case)
+      (%~) SCZ SCV = Disproved (\case)
+      (%~) SCZ SCW = Disproved (\case)
+      (%~) SCZ SCX = Disproved (\case)
+      (%~) SCZ SCY = Disproved (\case)
+      (%~) SCZ SCZ = Proved Refl
+    instance Eq (SAChar (z :: AChar)) where
+      (==) _ _ = True
+    instance GHC.Internal.Data.Type.Equality.TestEquality (SAChar :: AChar
+                                                                     -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
+        = Data.Singletons.Decide.decideEquality
+    instance GHC.Internal.Data.Type.Coercion.TestCoercion (SAChar :: AChar
+                                                                     -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
+        = Data.Singletons.Decide.decideCoercion
+    deriving instance (Data.Singletons.ShowSing.ShowSing U,
+                       Data.Singletons.ShowSing.ShowSing Nat) =>
+                      Show (SU (z :: U))
+    deriving instance Show (SAChar (z :: AChar))
+    instance SingI BOOL where
+      sing = SBOOL
+    instance SingI STRING where
+      sing = SSTRING
+    instance SingI NAT where
+      sing = SNAT
+    instance (SingI n, SingI n) =>
+             SingI (VEC (n :: U) (n :: Nat)) where
+      sing = SVEC sing sing
+    instance SingI n => SingI1 (VEC (n :: U)) where
+      liftSing = SVEC sing
+    instance SingI2 VEC where
+      liftSing2 = SVEC
+    instance SingI (VECSym0 :: (~>) U ((~>) Nat U)) where
+      sing = singFun2 @VECSym0 SVEC
+    instance SingI d => SingI (VECSym1 (d :: U) :: (~>) Nat U) where
+      sing = singFun1 @(VECSym1 (d :: U)) (SVEC (sing @d))
+    instance SingI1 (VECSym1 :: U -> (~>) Nat U) where
+      liftSing (s :: Sing (d :: U))
+        = singFun1 @(VECSym1 (d :: U)) (SVEC s)
+    instance SingI CA where
+      sing = SCA
+    instance SingI CB where
+      sing = SCB
+    instance SingI CC where
+      sing = SCC
+    instance SingI CD where
+      sing = SCD
+    instance SingI CE where
+      sing = SCE
+    instance SingI CF where
+      sing = SCF
+    instance SingI CG where
+      sing = SCG
+    instance SingI CH where
+      sing = SCH
+    instance SingI CI where
+      sing = SCI
+    instance SingI CJ where
+      sing = SCJ
+    instance SingI CK where
+      sing = SCK
+    instance SingI CL where
+      sing = SCL
+    instance SingI CM where
+      sing = SCM
+    instance SingI CN where
+      sing = SCN
+    instance SingI CO where
+      sing = SCO
+    instance SingI CP where
+      sing = SCP
+    instance SingI CQ where
+      sing = SCQ
+    instance SingI CR where
+      sing = SCR
+    instance SingI CS where
+      sing = SCS
+    instance SingI CT where
+      sing = SCT
+    instance SingI CU where
+      sing = SCU
+    instance SingI CV where
+      sing = SCV
+    instance SingI CW where
+      sing = SCW
+    instance SingI CX where
+      sing = SCX
+    instance SingI CY where
+      sing = SCY
+    instance SingI CZ where
+      sing = SCZ
+    instance (SingI n, SingI n) =>
+             SingI (Attr (n :: [AChar]) (n :: U)) where
+      sing = SAttr sing sing
+    instance SingI n => SingI1 (Attr (n :: [AChar])) where
+      liftSing = SAttr sing
+    instance SingI2 Attr where
+      liftSing2 = SAttr
+    instance SingI (AttrSym0 :: (~>) [AChar] ((~>) U Attribute)) where
+      sing = singFun2 @AttrSym0 SAttr
+    instance SingI d =>
+             SingI (AttrSym1 (d :: [AChar]) :: (~>) U Attribute) where
+      sing = singFun1 @(AttrSym1 (d :: [AChar])) (SAttr (sing @d))
+    instance SingI1 (AttrSym1 :: [AChar] -> (~>) U Attribute) where
+      liftSing (s :: Sing (d :: [AChar]))
+        = singFun1 @(AttrSym1 (d :: [AChar])) (SAttr s)
+    instance SingI n => SingI (Sch (n :: [Attribute])) where
+      sing = SSch sing
+    instance SingI1 Sch where
+      liftSing = SSch
+    instance SingI (SchSym0 :: (~>) [Attribute] Schema) where
+      sing = singFun1 @SchSym0 SSch
+GradingClient/Database.hs:0:0:: Splicing declarations
+    return [] ======>
+GradingClient/Database.hs:(0,0)-(0,0): Splicing expression
+    cases ''Row [| r |] [| changeId (n ++ (getId r)) r |]
+  ======>
+    (\cases
+       (EmptyRow _) -> changeId ((++) n (getId r)) r
+       (ConsRow _ _) -> changeId ((++) n (getId r)) r)
+      r
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
@@ -215,12 +215,12 @@
   (rowTail, strTail) <- readRow id (SSch at) st
   case elUReadInstance u of
     ElUReadInstance ->
-      let results = readsPrec 0 sh in
-      if null results
-        then throwError $ "No parse of " ++ sh ++ " as a " ++
-                          (show (fromSing u))
-        else
-          let item = fst $ head results in
+      case readsPrec 0 sh of
+        [] ->
+          throwError $ "No parse of " ++ sh ++ " as a " ++
+                       (show (fromSing u))
+        result:_ ->
+          let item = fst result in
           case elUShowInstance u of
             ElUShowInstance -> return (ConsRow item rowTail, strTail)
 
diff --git a/tests/compile-and-dump/GradingClient/Main.golden b/tests/compile-and-dump/GradingClient/Main.golden
--- a/tests/compile-and-dump/GradingClient/Main.golden
+++ b/tests/compile-and-dump/GradingClient/Main.golden
@@ -27,10 +27,10 @@
     gradingSchema :: Schema
     gradingSchema
       = Sch
-          [(Attr lastName) STRING, (Attr firstName) STRING,
-           (Attr yearName) NAT, (Attr gradeName) NAT, (Attr majorName) BOOL]
+          [Attr lastName STRING, Attr firstName STRING, Attr yearName NAT,
+           Attr gradeName NAT, Attr majorName BOOL]
     names :: Schema
-    names = Sch [(Attr firstName) STRING, (Attr lastName) STRING]
+    names = Sch [Attr firstName STRING, Attr lastName STRING]
     type NamesSym0 :: Schema
     type family NamesSym0 :: Schema where
       NamesSym0 = Names
@@ -73,72 +73,97 @@
     type LastName :: [AChar]
     type family LastName :: [AChar] where
       LastName = Apply (Apply (:@#@$) CLSym0) (Apply (Apply (:@#@$) CASym0) (Apply (Apply (:@#@$) CSSym0) (Apply (Apply (:@#@$) CTSym0) NilSym0)))
-    sNames :: Sing (NamesSym0 :: Schema)
-    sGradingSchema :: Sing (GradingSchemaSym0 :: Schema)
-    sMajorName :: Sing (MajorNameSym0 :: [AChar])
-    sGradeName :: Sing (GradeNameSym0 :: [AChar])
-    sYearName :: Sing (YearNameSym0 :: [AChar])
-    sFirstName :: Sing (FirstNameSym0 :: [AChar])
-    sLastName :: Sing (LastNameSym0 :: [AChar])
+    sNames :: (Sing (Names :: Schema) :: Type)
+    sGradingSchema :: (Sing (GradingSchema :: Schema) :: Type)
+    sMajorName :: (Sing (MajorName :: [AChar]) :: Type)
+    sGradeName :: (Sing (GradeName :: [AChar]) :: Type)
+    sYearName :: (Sing (YearName :: [AChar]) :: Type)
+    sFirstName :: (Sing (FirstName :: [AChar]) :: Type)
+    sLastName :: (Sing (LastName :: [AChar]) :: Type)
     sNames
-      = (applySing ((singFun1 @SchSym0) SSch))
-          ((applySing
-              ((applySing ((singFun2 @(:@#@$)) SCons))
-                 ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sFirstName))
-                    SSTRING)))
-             ((applySing
-                 ((applySing ((singFun2 @(:@#@$)) SCons))
-                    ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sLastName))
-                       SSTRING)))
+      = applySing
+          (singFun1 @SchSym0 SSch)
+          (applySing
+             (applySing
+                (singFun2 @(:@#@$) SCons)
+                (applySing
+                   (applySing (singFun2 @AttrSym0 SAttr) sFirstName) SSTRING))
+             (applySing
+                (applySing
+                   (singFun2 @(:@#@$) SCons)
+                   (applySing
+                      (applySing (singFun2 @AttrSym0 SAttr) sLastName) SSTRING))
                 SNil))
     sGradingSchema
-      = (applySing ((singFun1 @SchSym0) SSch))
-          ((applySing
-              ((applySing ((singFun2 @(:@#@$)) SCons))
-                 ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sLastName))
-                    SSTRING)))
-             ((applySing
-                 ((applySing ((singFun2 @(:@#@$)) SCons))
-                    ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sFirstName))
-                       SSTRING)))
-                ((applySing
-                    ((applySing ((singFun2 @(:@#@$)) SCons))
-                       ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sYearName))
-                          SNAT)))
-                   ((applySing
-                       ((applySing ((singFun2 @(:@#@$)) SCons))
-                          ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sGradeName))
-                             SNAT)))
-                      ((applySing
-                          ((applySing ((singFun2 @(:@#@$)) SCons))
-                             ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sMajorName))
-                                SBOOL)))
+      = applySing
+          (singFun1 @SchSym0 SSch)
+          (applySing
+             (applySing
+                (singFun2 @(:@#@$) SCons)
+                (applySing
+                   (applySing (singFun2 @AttrSym0 SAttr) sLastName) SSTRING))
+             (applySing
+                (applySing
+                   (singFun2 @(:@#@$) SCons)
+                   (applySing
+                      (applySing (singFun2 @AttrSym0 SAttr) sFirstName) SSTRING))
+                (applySing
+                   (applySing
+                      (singFun2 @(:@#@$) SCons)
+                      (applySing (applySing (singFun2 @AttrSym0 SAttr) sYearName) SNAT))
+                   (applySing
+                      (applySing
+                         (singFun2 @(:@#@$) SCons)
+                         (applySing (applySing (singFun2 @AttrSym0 SAttr) sGradeName) SNAT))
+                      (applySing
+                         (applySing
+                            (singFun2 @(:@#@$) SCons)
+                            (applySing
+                               (applySing (singFun2 @AttrSym0 SAttr) sMajorName) SBOOL))
                          SNil)))))
     sMajorName
-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCM))
-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))
-             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCJ))
-                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCO))
-                   ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR)) SNil))))
+      = applySing
+          (applySing (singFun2 @(:@#@$) SCons) SCM)
+          (applySing
+             (applySing (singFun2 @(:@#@$) SCons) SCA)
+             (applySing
+                (applySing (singFun2 @(:@#@$) SCons) SCJ)
+                (applySing
+                   (applySing (singFun2 @(:@#@$) SCons) SCO)
+                   (applySing (applySing (singFun2 @(:@#@$) SCons) SCR) SNil))))
     sGradeName
-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCG))
-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR))
-             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))
-                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCD))
-                   ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCE)) SNil))))
+      = applySing
+          (applySing (singFun2 @(:@#@$) SCons) SCG)
+          (applySing
+             (applySing (singFun2 @(:@#@$) SCons) SCR)
+             (applySing
+                (applySing (singFun2 @(:@#@$) SCons) SCA)
+                (applySing
+                   (applySing (singFun2 @(:@#@$) SCons) SCD)
+                   (applySing (applySing (singFun2 @(:@#@$) SCons) SCE) SNil))))
     sYearName
-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCY))
-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCE))
-             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))
-                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR)) SNil)))
+      = applySing
+          (applySing (singFun2 @(:@#@$) SCons) SCY)
+          (applySing
+             (applySing (singFun2 @(:@#@$) SCons) SCE)
+             (applySing
+                (applySing (singFun2 @(:@#@$) SCons) SCA)
+                (applySing (applySing (singFun2 @(:@#@$) SCons) SCR) SNil)))
     sFirstName
-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCF))
-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCI))
-             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR))
-                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCS))
-                   ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCT)) SNil))))
+      = applySing
+          (applySing (singFun2 @(:@#@$) SCons) SCF)
+          (applySing
+             (applySing (singFun2 @(:@#@$) SCons) SCI)
+             (applySing
+                (applySing (singFun2 @(:@#@$) SCons) SCR)
+                (applySing
+                   (applySing (singFun2 @(:@#@$) SCons) SCS)
+                   (applySing (applySing (singFun2 @(:@#@$) SCons) SCT) SNil))))
     sLastName
-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCL))
-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))
-             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCS))
-                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCT)) SNil)))
+      = applySing
+          (applySing (singFun2 @(:@#@$) SCons) SCL)
+          (applySing
+             (applySing (singFun2 @(:@#@$) SCons) SCA)
+             (applySing
+                (applySing (singFun2 @(:@#@$) SCons) SCS)
+                (applySing (applySing (singFun2 @(:@#@$) SCons) SCT) SNil)))
diff --git a/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden b/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden
--- a/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden
+++ b/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden
@@ -10,9 +10,9 @@
       where
         SuccSym0KindInference :: SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>
                                  SuccSym0 a0123456789876543210
-    type instance Apply SuccSym0 a0123456789876543210 = Succ a0123456789876543210
+    type instance Apply @Nat @Nat SuccSym0 a0123456789876543210 = Succ a0123456789876543210
     instance SuppressUnusedWarnings SuccSym0 where
-      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SuccSym0KindInference ())
     type SuccSym1 :: Nat -> Nat
     type family SuccSym1 (a0123456789876543210 :: Nat) :: Nat where
       SuccSym1 a0123456789876543210 = Succ a0123456789876543210
@@ -27,7 +27,8 @@
       fromSing (SSucc b) = Succ (fromSing b)
       toSing Zero = SomeSing SZero
       toSing (Succ (b :: Demote Nat))
-        = case toSing b :: SomeSing Nat of SomeSing c -> SomeSing (SSucc c)
+        = (\cases (SomeSing c) -> SomeSing (SSucc c))
+            (toSing b :: SomeSing Nat)
     instance SingI Zero where
       sing = SZero
     instance SingI n => SingI (Succ (n :: Nat)) where
@@ -35,7 +36,7 @@
     instance SingI1 Succ where
       liftSing = SSucc
     instance SingI (SuccSym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @SuccSym0) SSucc
+      sing = singFun1 @SuccSym0 SSucc
 InsertionSort/InsertionSortImp.hs:(0,0)-(0,0): Splicing declarations
     singletons
       [d| leq :: Nat -> Nat -> Bool
@@ -53,63 +54,36 @@
     leq :: Nat -> Nat -> Bool
     leq Zero _ = True
     leq (Succ _) Zero = False
-    leq (Succ a) (Succ b) = (leq a) b
+    leq (Succ a) (Succ b) = leq a b
     insert :: Nat -> [Nat] -> [Nat]
     insert n [] = [n]
     insert n (h : t)
-      = if (leq n) h then (n : (h : t)) else (h : (insert n) t)
+      = if leq n h then (n : (h : t)) else (h : insert n t)
     insertionSort :: [Nat] -> [Nat]
     insertionSort [] = []
-    insertionSort (h : t) = (insert h) (insertionSort t)
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 n0123456789876543210
-      where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 n0123456789876543210
-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 n0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)
-               ())
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210 h0123456789876543210
-      where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210 h0123456789876543210
-    type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210) h0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210) where
-      suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference)
-               ())
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210 t0123456789876543210
+    insertionSort (h : t) = insert h (insertionSort t)
+    type family LamCases_0123456789876543210 (n0123456789876543210 :: Nat) h0123456789876543210 t0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 n h t 'True = Apply (Apply (:@#@$) n) (Apply (Apply (:@#@$) h) t)
+      LamCases_0123456789876543210 n h t 'False = Apply (Apply (:@#@$) h) (Apply (Apply InsertSym0 n) t)
+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: Nat) h0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym3 n0123456789876543210 h0123456789876543210 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210 t0123456789876543210
-    type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210) t0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 n0123456789876543210 h0123456789876543210 t0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210 h0123456789876543210 t0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 h0123456789876543210 t0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 h0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210 h0123456789876543210 t0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 h0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210 h0123456789876543210 t0123456789876543210) where
       suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference)
-               ())
-    type family Let0123456789876543210Scrutinee_0123456789876543210Sym3 n0123456789876543210 h0123456789876543210 t0123456789876543210 where
-      Let0123456789876543210Scrutinee_0123456789876543210Sym3 n0123456789876543210 h0123456789876543210 t0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 n0123456789876543210 h0123456789876543210 t0123456789876543210
-    type family Let0123456789876543210Scrutinee_0123456789876543210 n h t where
-      Let0123456789876543210Scrutinee_0123456789876543210 n h t = Apply (Apply LeqSym0 n) h
-    type family Case_0123456789876543210 n h t t where
-      Case_0123456789876543210 n h t 'True = Apply (Apply (:@#@$) n) (Apply (Apply (:@#@$) h) t)
-      Case_0123456789876543210 n h t 'False = Apply (Apply (:@#@$) h) (Apply (Apply InsertSym0 n) t)
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: Nat) h0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 h0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 h0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210
     type InsertionSortSym0 :: (~>) [Nat] [Nat]
     data InsertionSortSym0 :: (~>) [Nat] [Nat]
       where
         InsertionSortSym0KindInference :: SameKind (Apply InsertionSortSym0 arg) (InsertionSortSym1 arg) =>
                                           InsertionSortSym0 a0123456789876543210
-    type instance Apply InsertionSortSym0 a0123456789876543210 = InsertionSort a0123456789876543210
+    type instance Apply @[Nat] @[Nat] InsertionSortSym0 a0123456789876543210 = InsertionSort a0123456789876543210
     instance SuppressUnusedWarnings InsertionSortSym0 where
       suppressUnusedWarnings
-        = snd (((,) InsertionSortSym0KindInference) ())
+        = snd ((,) InsertionSortSym0KindInference ())
     type InsertionSortSym1 :: [Nat] -> [Nat]
     type family InsertionSortSym1 (a0123456789876543210 :: [Nat]) :: [Nat] where
       InsertionSortSym1 a0123456789876543210 = InsertionSort a0123456789876543210
@@ -118,17 +92,17 @@
       where
         InsertSym0KindInference :: SameKind (Apply InsertSym0 arg) (InsertSym1 arg) =>
                                    InsertSym0 a0123456789876543210
-    type instance Apply InsertSym0 a0123456789876543210 = InsertSym1 a0123456789876543210
+    type instance Apply @Nat @((~>) [Nat] [Nat]) InsertSym0 a0123456789876543210 = InsertSym1 a0123456789876543210
     instance SuppressUnusedWarnings InsertSym0 where
-      suppressUnusedWarnings = snd (((,) InsertSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) InsertSym0KindInference ())
     type InsertSym1 :: Nat -> (~>) [Nat] [Nat]
     data InsertSym1 (a0123456789876543210 :: Nat) :: (~>) [Nat] [Nat]
       where
         InsertSym1KindInference :: SameKind (Apply (InsertSym1 a0123456789876543210) arg) (InsertSym2 a0123456789876543210 arg) =>
                                    InsertSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (InsertSym1 a0123456789876543210) a0123456789876543210 = Insert a0123456789876543210 a0123456789876543210
+    type instance Apply @[Nat] @[Nat] (InsertSym1 a0123456789876543210) a0123456789876543210 = Insert a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (InsertSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) InsertSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) InsertSym1KindInference ())
     type InsertSym2 :: Nat -> [Nat] -> [Nat]
     type family InsertSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: [Nat]) :: [Nat] where
       InsertSym2 a0123456789876543210 a0123456789876543210 = Insert a0123456789876543210 a0123456789876543210
@@ -137,17 +111,17 @@
       where
         LeqSym0KindInference :: SameKind (Apply LeqSym0 arg) (LeqSym1 arg) =>
                                 LeqSym0 a0123456789876543210
-    type instance Apply LeqSym0 a0123456789876543210 = LeqSym1 a0123456789876543210
+    type instance Apply @Nat @((~>) Nat Bool) LeqSym0 a0123456789876543210 = LeqSym1 a0123456789876543210
     instance SuppressUnusedWarnings LeqSym0 where
-      suppressUnusedWarnings = snd (((,) LeqSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) LeqSym0KindInference ())
     type LeqSym1 :: Nat -> (~>) Nat Bool
     data LeqSym1 (a0123456789876543210 :: Nat) :: (~>) Nat Bool
       where
         LeqSym1KindInference :: SameKind (Apply (LeqSym1 a0123456789876543210) arg) (LeqSym2 a0123456789876543210 arg) =>
                                 LeqSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (LeqSym1 a0123456789876543210) a0123456789876543210 = Leq a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Bool (LeqSym1 a0123456789876543210) a0123456789876543210 = Leq a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (LeqSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) LeqSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) LeqSym1KindInference ())
     type LeqSym2 :: Nat -> Nat -> Bool
     type family LeqSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Bool where
       LeqSym2 a0123456789876543210 a0123456789876543210 = Leq a0123456789876543210 a0123456789876543210
@@ -158,62 +132,61 @@
     type Insert :: Nat -> [Nat] -> [Nat]
     type family Insert (a :: Nat) (a :: [Nat]) :: [Nat] where
       Insert n '[] = Apply (Apply (:@#@$) n) NilSym0
-      Insert n ('(:) h t) = Case_0123456789876543210 n h t (Let0123456789876543210Scrutinee_0123456789876543210Sym3 n h t)
+      Insert n ('(:) h t) = Apply (LamCases_0123456789876543210Sym0 n h t) (Apply (Apply LeqSym0 n) h)
     type Leq :: Nat -> Nat -> Bool
     type family Leq (a :: Nat) (a :: Nat) :: Bool where
       Leq 'Zero _ = TrueSym0
       Leq ('Succ _) 'Zero = FalseSym0
       Leq ('Succ a) ('Succ b) = Apply (Apply LeqSym0 a) b
     sInsertionSort ::
-      forall (t :: [Nat]). Sing t
-                           -> Sing (Apply InsertionSortSym0 t :: [Nat])
+      (forall (t :: [Nat]).
+       Sing t -> Sing (InsertionSort t :: [Nat]) :: Type)
     sInsert ::
-      forall (t :: Nat) (t :: [Nat]). Sing t
-                                      -> Sing t -> Sing (Apply (Apply InsertSym0 t) t :: [Nat])
+      (forall (t :: Nat) (t :: [Nat]).
+       Sing t -> Sing t -> Sing (Insert t t :: [Nat]) :: Type)
     sLeq ::
-      forall (t :: Nat) (t :: Nat). Sing t
-                                    -> Sing t -> Sing (Apply (Apply LeqSym0 t) t :: Bool)
+      (forall (t :: Nat) (t :: Nat).
+       Sing t -> Sing t -> Sing (Leq t t :: Bool) :: Type)
     sInsertionSort SNil = SNil
     sInsertionSort (SCons (sH :: Sing h) (sT :: Sing t))
-      = (applySing ((applySing ((singFun2 @InsertSym0) sInsert)) sH))
-          ((applySing ((singFun1 @InsertionSortSym0) sInsertionSort)) sT)
+      = applySing
+          (applySing (singFun2 @InsertSym0 sInsert) sH)
+          (applySing (singFun1 @InsertionSortSym0 sInsertionSort) sT)
     sInsert (sN :: Sing n) SNil
-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) sN)) SNil
+      = applySing (applySing (singFun2 @(:@#@$) SCons) sN) SNil
     sInsert (sN :: Sing n) (SCons (sH :: Sing h) (sT :: Sing t))
-      = let
-          sScrutinee_0123456789876543210 ::
-            Sing @_ (Let0123456789876543210Scrutinee_0123456789876543210Sym3 n h t)
-          sScrutinee_0123456789876543210
-            = (applySing ((applySing ((singFun2 @LeqSym0) sLeq)) sN)) sH
-        in
-          (id
-             @(Sing (Case_0123456789876543210 n h t (Let0123456789876543210Scrutinee_0123456789876543210Sym3 n h t) :: [Nat])))
-            (case sScrutinee_0123456789876543210 of
-               STrue
-                 -> (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) sN))
-                      ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) sH)) sT)
-               SFalse
-                 -> (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) sH))
-                      ((applySing ((applySing ((singFun2 @InsertSym0) sInsert)) sN)) sT))
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 n h t)
+             (\cases
+                STrue
+                  -> applySing
+                       (applySing (singFun2 @(:@#@$) SCons) sN)
+                       (applySing (applySing (singFun2 @(:@#@$) SCons) sH) sT)
+                SFalse
+                  -> applySing
+                       (applySing (singFun2 @(:@#@$) SCons) sH)
+                       (applySing (applySing (singFun2 @InsertSym0 sInsert) sN) sT)))
+          (applySing (applySing (singFun2 @LeqSym0 sLeq) sN) sH)
     sLeq SZero _ = STrue
     sLeq (SSucc _) SZero = SFalse
     sLeq (SSucc (sA :: Sing a)) (SSucc (sB :: Sing b))
-      = (applySing ((applySing ((singFun2 @LeqSym0) sLeq)) sA)) sB
+      = applySing (applySing (singFun2 @LeqSym0 sLeq) sA) sB
     instance SingI (InsertionSortSym0 :: (~>) [Nat] [Nat]) where
-      sing = (singFun1 @InsertionSortSym0) sInsertionSort
+      sing = singFun1 @InsertionSortSym0 sInsertionSort
     instance SingI (InsertSym0 :: (~>) Nat ((~>) [Nat] [Nat])) where
-      sing = (singFun2 @InsertSym0) sInsert
+      sing = singFun2 @InsertSym0 sInsert
     instance SingI d =>
              SingI (InsertSym1 (d :: Nat) :: (~>) [Nat] [Nat]) where
-      sing = (singFun1 @(InsertSym1 (d :: Nat))) (sInsert (sing @d))
+      sing = singFun1 @(InsertSym1 (d :: Nat)) (sInsert (sing @d))
     instance SingI1 (InsertSym1 :: Nat -> (~>) [Nat] [Nat]) where
       liftSing (s :: Sing (d :: Nat))
-        = (singFun1 @(InsertSym1 (d :: Nat))) (sInsert s)
+        = singFun1 @(InsertSym1 (d :: Nat)) (sInsert s)
     instance SingI (LeqSym0 :: (~>) Nat ((~>) Nat Bool)) where
-      sing = (singFun2 @LeqSym0) sLeq
+      sing = singFun2 @LeqSym0 sLeq
     instance SingI d =>
              SingI (LeqSym1 (d :: Nat) :: (~>) Nat Bool) where
-      sing = (singFun1 @(LeqSym1 (d :: Nat))) (sLeq (sing @d))
+      sing = singFun1 @(LeqSym1 (d :: Nat)) (sLeq (sing @d))
     instance SingI1 (LeqSym1 :: Nat -> (~>) Nat Bool) where
       liftSing (s :: Sing (d :: Nat))
-        = (singFun1 @(LeqSym1 (d :: Nat))) (sLeq s)
+        = singFun1 @(LeqSym1 (d :: Nat)) (sLeq s)
diff --git a/tests/compile-and-dump/Promote/Constructors.golden b/tests/compile-and-dump/Promote/Constructors.golden
--- a/tests/compile-and-dump/Promote/Constructors.golden
+++ b/tests/compile-and-dump/Promote/Constructors.golden
@@ -13,17 +13,17 @@
       where
         (::+@#@$###) :: SameKind (Apply (:+@#@$) arg) ((:+@#@$$) arg) =>
                         (:+@#@$) a0123456789876543210
-    type instance Apply (:+@#@$) a0123456789876543210 = (:+@#@$$) a0123456789876543210
+    type instance Apply @Foo @((~>) Foo Foo) (:+@#@$) a0123456789876543210 = (:+@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:+@#@$) where
-      suppressUnusedWarnings = snd (((,) (::+@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (::+@#@$###) ())
     type (:+@#@$$) :: Foo -> (~>) Foo Foo
     data (:+@#@$$) (a0123456789876543210 :: Foo) :: (~>) Foo Foo
       where
         (::+@#@$$###) :: SameKind (Apply ((:+@#@$$) a0123456789876543210) arg) ((:+@#@$$$) a0123456789876543210 arg) =>
                          (:+@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:+@#@$$) a0123456789876543210) a0123456789876543210 = (:+) a0123456789876543210 a0123456789876543210
+    type instance Apply @Foo @Foo ((:+@#@$$) a0123456789876543210) a0123456789876543210 = (:+) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:+@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::+@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (::+@#@$$###) ())
     type (:+@#@$$$) :: Foo -> Foo -> Foo
     type family (:+@#@$$$) (a0123456789876543210 :: Foo) (a0123456789876543210 :: Foo) :: Foo where
       (:+@#@$$$) a0123456789876543210 a0123456789876543210 = (:+) a0123456789876543210 a0123456789876543210
@@ -32,42 +32,42 @@
       where
         BarSym0KindInference :: SameKind (Apply BarSym0 arg) (BarSym1 arg) =>
                                 BarSym0 a0123456789876543210
-    type instance Apply BarSym0 a0123456789876543210 = BarSym1 a0123456789876543210
+    type instance Apply @Bar @((~>) Bar ((~>) Bar ((~>) Bar ((~>) Foo Bar)))) BarSym0 a0123456789876543210 = BarSym1 a0123456789876543210
     instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BarSym0KindInference ())
     type BarSym1 :: Bar
                     -> (~>) Bar ((~>) Bar ((~>) Bar ((~>) Foo Bar)))
     data BarSym1 (a0123456789876543210 :: Bar) :: (~>) Bar ((~>) Bar ((~>) Bar ((~>) Foo Bar)))
       where
         BarSym1KindInference :: SameKind (Apply (BarSym1 a0123456789876543210) arg) (BarSym2 a0123456789876543210 arg) =>
                                 BarSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (BarSym1 a0123456789876543210) a0123456789876543210 = BarSym2 a0123456789876543210 a0123456789876543210
+    type instance Apply @Bar @((~>) Bar ((~>) Bar ((~>) Foo Bar))) (BarSym1 a0123456789876543210) a0123456789876543210 = BarSym2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (BarSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BarSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) BarSym1KindInference ())
     type BarSym2 :: Bar -> Bar -> (~>) Bar ((~>) Bar ((~>) Foo Bar))
     data BarSym2 (a0123456789876543210 :: Bar) (a0123456789876543210 :: Bar) :: (~>) Bar ((~>) Bar ((~>) Foo Bar))
       where
         BarSym2KindInference :: SameKind (Apply (BarSym2 a0123456789876543210 a0123456789876543210) arg) (BarSym3 a0123456789876543210 a0123456789876543210 arg) =>
                                 BarSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (BarSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = BarSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @Bar @((~>) Bar ((~>) Foo Bar)) (BarSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = BarSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (BarSym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BarSym2KindInference) ())
+      suppressUnusedWarnings = snd ((,) BarSym2KindInference ())
     type BarSym3 :: Bar -> Bar -> Bar -> (~>) Bar ((~>) Foo Bar)
     data BarSym3 (a0123456789876543210 :: Bar) (a0123456789876543210 :: Bar) (a0123456789876543210 :: Bar) :: (~>) Bar ((~>) Foo Bar)
       where
         BarSym3KindInference :: SameKind (Apply (BarSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (BarSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
                                 BarSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (BarSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = BarSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @Bar @((~>) Foo Bar) (BarSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = BarSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (BarSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BarSym3KindInference) ())
+      suppressUnusedWarnings = snd ((,) BarSym3KindInference ())
     type BarSym4 :: Bar -> Bar -> Bar -> Bar -> (~>) Foo Bar
     data BarSym4 (a0123456789876543210 :: Bar) (a0123456789876543210 :: Bar) (a0123456789876543210 :: Bar) (a0123456789876543210 :: Bar) :: (~>) Foo Bar
       where
         BarSym4KindInference :: SameKind (Apply (BarSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (BarSym5 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
                                 BarSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (BarSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @Foo @Bar (BarSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (BarSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BarSym4KindInference) ())
+      suppressUnusedWarnings = snd ((,) BarSym4KindInference ())
     type BarSym5 :: Bar -> Bar -> Bar -> Bar -> Foo -> Bar
     type family BarSym5 (a0123456789876543210 :: Bar) (a0123456789876543210 :: Bar) (a0123456789876543210 :: Bar) (a0123456789876543210 :: Bar) (a0123456789876543210 :: Foo) :: Bar where
       BarSym5 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
diff --git a/tests/compile-and-dump/Promote/GenDefunSymbols.golden b/tests/compile-and-dump/Promote/GenDefunSymbols.golden
--- a/tests/compile-and-dump/Promote/GenDefunSymbols.golden
+++ b/tests/compile-and-dump/Promote/GenDefunSymbols.golden
@@ -7,23 +7,23 @@
       where
         LiftMaybeSym0KindInference :: Data.Singletons.SameKind (Apply LiftMaybeSym0 arg) (LiftMaybeSym1 arg) =>
                                       LiftMaybeSym0 a0123456789876543210
-    type instance Apply LiftMaybeSym0 a0123456789876543210 = LiftMaybeSym1 a0123456789876543210
+    type instance Apply @((~>) a b) @((~>) (Maybe a) (Maybe b)) LiftMaybeSym0 a0123456789876543210 = LiftMaybeSym1 a0123456789876543210
     instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings LiftMaybeSym0 where
       Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
-        = snd (((,) LiftMaybeSym0KindInference) ())
+        = snd ((,) LiftMaybeSym0KindInference ())
     type LiftMaybeSym1 :: forall (a :: Type) (b :: Type). (~>) a b
                                                           -> (~>) (Maybe a) (Maybe b)
     data LiftMaybeSym1 (a0123456789876543210 :: (~>) a b) :: (~>) (Maybe a) (Maybe b)
       where
         LiftMaybeSym1KindInference :: Data.Singletons.SameKind (Apply (LiftMaybeSym1 a0123456789876543210) arg) (LiftMaybeSym2 a0123456789876543210 arg) =>
                                       LiftMaybeSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (LiftMaybeSym1 a0123456789876543210) a0123456789876543210 = LiftMaybe a0123456789876543210 a0123456789876543210
+    type instance Apply @(Maybe a) @(Maybe b) (LiftMaybeSym1 a0123456789876543210) a0123456789876543210 = LiftMaybe a0123456789876543210 a0123456789876543210
     instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings (LiftMaybeSym1 a0123456789876543210) where
       Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
-        = snd (((,) LiftMaybeSym1KindInference) ())
+        = snd ((,) LiftMaybeSym1KindInference ())
     type LiftMaybeSym2 :: forall (a :: Type) (b :: Type). (~>) a b
                                                           -> Maybe a -> Maybe b
-    type family LiftMaybeSym2 (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: Maybe a) :: Maybe b where
+    type family LiftMaybeSym2 @(a :: Type) @(b :: Type) (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: Maybe a) :: Maybe b where
       LiftMaybeSym2 a0123456789876543210 a0123456789876543210 = LiftMaybe a0123456789876543210 a0123456789876543210
     type ZeroSym0 :: NatT
     type family ZeroSym0 :: NatT where
@@ -33,10 +33,10 @@
       where
         SuccSym0KindInference :: Data.Singletons.SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>
                                  SuccSym0 a0123456789876543210
-    type instance Apply SuccSym0 a0123456789876543210 = 'Succ a0123456789876543210
+    type instance Apply @NatT @NatT SuccSym0 a0123456789876543210 = 'Succ a0123456789876543210
     instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings SuccSym0 where
       Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
-        = snd (((,) SuccSym0KindInference) ())
+        = snd ((,) SuccSym0KindInference ())
     type SuccSym1 :: NatT -> NatT
     type family SuccSym1 (a0123456789876543210 :: NatT) :: NatT where
       SuccSym1 a0123456789876543210 = 'Succ a0123456789876543210
@@ -45,19 +45,19 @@
       where
         (::+@#@$###) :: Data.Singletons.SameKind (Apply (:+@#@$) arg) ((:+@#@$$) arg) =>
                         (:+@#@$) a0123456789876543210
-    type instance Apply (:+@#@$) a0123456789876543210 = (:+@#@$$) a0123456789876543210
+    type instance Apply @Natural @((~>) Natural Natural) (:+@#@$) a0123456789876543210 = (:+@#@$$) a0123456789876543210
     instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings (:+@#@$) where
       Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
-        = snd (((,) (::+@#@$###)) ())
+        = snd ((,) (::+@#@$###) ())
     type (:+@#@$$) :: Natural -> (~>) Natural Natural
     data (:+@#@$$) (a0123456789876543210 :: Natural) :: (~>) Natural Natural
       where
         (::+@#@$$###) :: Data.Singletons.SameKind (Apply ((:+@#@$$) a0123456789876543210) arg) ((:+@#@$$$) a0123456789876543210 arg) =>
                          (:+@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:+@#@$$) a0123456789876543210) a0123456789876543210 = (:+) a0123456789876543210 a0123456789876543210
+    type instance Apply @Natural @Natural ((:+@#@$$) a0123456789876543210) a0123456789876543210 = (:+) a0123456789876543210 a0123456789876543210
     instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings ((:+@#@$$) a0123456789876543210) where
       Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
-        = snd (((,) (::+@#@$$###)) ())
+        = snd ((,) (::+@#@$$###) ())
     type (:+@#@$$$) :: Natural -> Natural -> Natural
     type family (:+@#@$$$) (a0123456789876543210 :: Natural) (a0123456789876543210 :: Natural) :: Natural where
       (:+@#@$$$) a0123456789876543210 a0123456789876543210 = (:+) a0123456789876543210 a0123456789876543210
diff --git a/tests/compile-and-dump/Promote/Newtypes.golden b/tests/compile-and-dump/Promote/Newtypes.golden
--- a/tests/compile-and-dump/Promote/Newtypes.golden
+++ b/tests/compile-and-dump/Promote/Newtypes.golden
@@ -14,9 +14,9 @@
       where
         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
                                 FooSym0 a0123456789876543210
-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210
+    type instance Apply @Nat @Foo FooSym0 a0123456789876543210 = Foo a0123456789876543210
     instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
     type FooSym1 :: Nat -> Foo
     type family FooSym1 (a0123456789876543210 :: Nat) :: Foo where
       FooSym1 a0123456789876543210 = Foo a0123456789876543210
@@ -25,9 +25,9 @@
       where
         BarSym0KindInference :: SameKind (Apply BarSym0 arg) (BarSym1 arg) =>
                                 BarSym0 a0123456789876543210
-    type instance Apply BarSym0 a0123456789876543210 = Bar a0123456789876543210
+    type instance Apply @Nat @Bar BarSym0 a0123456789876543210 = Bar a0123456789876543210
     instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BarSym0KindInference ())
     type BarSym1 :: Nat -> Bar
     type family BarSym1 (a0123456789876543210 :: Nat) :: Bar where
       BarSym1 a0123456789876543210 = Bar a0123456789876543210
@@ -36,9 +36,9 @@
       where
         UnBarSym0KindInference :: SameKind (Apply UnBarSym0 arg) (UnBarSym1 arg) =>
                                   UnBarSym0 a0123456789876543210
-    type instance Apply UnBarSym0 a0123456789876543210 = UnBar a0123456789876543210
+    type instance Apply @Bar @Nat UnBarSym0 a0123456789876543210 = UnBar a0123456789876543210
     instance SuppressUnusedWarnings UnBarSym0 where
-      suppressUnusedWarnings = snd (((,) UnBarSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) UnBarSym0KindInference ())
     type UnBarSym1 :: Bar -> Nat
     type family UnBarSym1 (a0123456789876543210 :: Bar) :: Nat where
       UnBarSym1 a0123456789876543210 = UnBar a0123456789876543210
@@ -48,26 +48,5 @@
     type TFHelper_0123456789876543210 :: Foo -> Foo -> Bool
     type family TFHelper_0123456789876543210 (a :: Foo) (a :: Foo) :: Bool where
       TFHelper_0123456789876543210 (Foo a_0123456789876543210) (Foo b_0123456789876543210) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
-    type TFHelper_0123456789876543210Sym0 :: (~>) Foo ((~>) Foo Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) Foo ((~>) Foo Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Foo -> (~>) Foo Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Foo) :: (~>) Foo Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Foo -> Foo -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Foo) (a0123456789876543210 :: Foo) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PEq Foo where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
+      type (==) a a = TFHelper_0123456789876543210 a a
diff --git a/tests/compile-and-dump/Promote/Prelude.golden b/tests/compile-and-dump/Promote/Prelude.golden
--- a/tests/compile-and-dump/Promote/Prelude.golden
+++ b/tests/compile-and-dump/Promote/Prelude.golden
@@ -9,9 +9,9 @@
       where
         OddSym0KindInference :: SameKind (Apply OddSym0 arg) (OddSym1 arg) =>
                                 OddSym0 a0123456789876543210
-    type instance Apply OddSym0 a0123456789876543210 = Odd a0123456789876543210
+    type instance Apply @Natural @Bool OddSym0 a0123456789876543210 = Odd a0123456789876543210
     instance SuppressUnusedWarnings OddSym0 where
-      suppressUnusedWarnings = snd (((,) OddSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) OddSym0KindInference ())
     type OddSym1 :: Natural -> Bool
     type family OddSym1 (a0123456789876543210 :: Natural) :: Bool where
       OddSym1 a0123456789876543210 = Odd a0123456789876543210
diff --git a/tests/compile-and-dump/Promote/T180.golden b/tests/compile-and-dump/Promote/T180.golden
--- a/tests/compile-and-dump/Promote/T180.golden
+++ b/tests/compile-and-dump/Promote/T180.golden
@@ -13,9 +13,9 @@
       where
         X1Sym0KindInference :: SameKind (Apply X1Sym0 arg) (X1Sym1 arg) =>
                                X1Sym0 a0123456789876543210
-    type instance Apply X1Sym0 a0123456789876543210 = X1 a0123456789876543210
+    type instance Apply @Symbol @X X1Sym0 a0123456789876543210 = X1 a0123456789876543210
     instance SuppressUnusedWarnings X1Sym0 where
-      suppressUnusedWarnings = snd (((,) X1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) X1Sym0KindInference ())
     type X1Sym1 :: Symbol -> X
     type family X1Sym1 (a0123456789876543210 :: Symbol) :: X where
       X1Sym1 a0123456789876543210 = X1 a0123456789876543210
@@ -24,9 +24,9 @@
       where
         X2Sym0KindInference :: SameKind (Apply X2Sym0 arg) (X2Sym1 arg) =>
                                X2Sym0 a0123456789876543210
-    type instance Apply X2Sym0 a0123456789876543210 = X2 a0123456789876543210
+    type instance Apply @Symbol @X X2Sym0 a0123456789876543210 = X2 a0123456789876543210
     instance SuppressUnusedWarnings X2Sym0 where
-      suppressUnusedWarnings = snd (((,) X2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) X2Sym0KindInference ())
     type X2Sym1 :: Symbol -> X
     type family X2Sym1 (a0123456789876543210 :: Symbol) :: X where
       X2Sym1 a0123456789876543210 = X2 a0123456789876543210
@@ -34,9 +34,9 @@
       where
         ZSym0KindInference :: SameKind (Apply ZSym0 arg) (ZSym1 arg) =>
                               ZSym0 a0123456789876543210
-    type instance Apply ZSym0 a0123456789876543210 = Z a0123456789876543210
+    type instance Apply @_ @_ ZSym0 a0123456789876543210 = Z a0123456789876543210
     instance SuppressUnusedWarnings ZSym0 where
-      suppressUnusedWarnings = snd (((,) ZSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) ZSym0KindInference ())
     type family ZSym1 a0123456789876543210 where
       ZSym1 a0123456789876543210 = Z a0123456789876543210
     type YSym0 :: (~>) X Symbol
@@ -44,9 +44,9 @@
       where
         YSym0KindInference :: SameKind (Apply YSym0 arg) (YSym1 arg) =>
                               YSym0 a0123456789876543210
-    type instance Apply YSym0 a0123456789876543210 = Y a0123456789876543210
+    type instance Apply @X @Symbol YSym0 a0123456789876543210 = Y a0123456789876543210
     instance SuppressUnusedWarnings YSym0 where
-      suppressUnusedWarnings = snd (((,) YSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) YSym0KindInference ())
     type YSym1 :: X -> Symbol
     type family YSym1 (a0123456789876543210 :: X) :: Symbol where
       YSym1 a0123456789876543210 = Y a0123456789876543210
diff --git a/tests/compile-and-dump/Promote/T361.golden b/tests/compile-and-dump/Promote/T361.golden
--- a/tests/compile-and-dump/Promote/T361.golden
+++ b/tests/compile-and-dump/Promote/T361.golden
@@ -1,8 +1,8 @@
 Promote/T361.hs:0:0:: Splicing declarations
     genDefunSymbols [''Proxy]
   ======>
-    type ProxySym0 :: forall k (t :: k). Proxy (t :: k)
-    type family ProxySym0 :: Proxy (t :: k) where
+    type ProxySym0 :: forall {k :: Type} (t :: k). Proxy t
+    type family ProxySym0 @(t :: k) :: Proxy t where
       ProxySym0 = 'Proxy
 Promote/T361.hs:(0,0)-(0,0): Splicing declarations
     promote
@@ -16,9 +16,9 @@
       where
         FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
                               FSym0 a0123456789876543210
-    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210
+    type instance Apply @(Proxy 1) @(Proxy 2) FSym0 a0123456789876543210 = F a0123456789876543210
     instance SuppressUnusedWarnings FSym0 where
-      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FSym0KindInference ())
     type FSym1 :: Proxy 1 -> Proxy 2
     type family FSym1 (a0123456789876543210 :: Proxy 1) :: Proxy 2 where
       FSym1 a0123456789876543210 = F a0123456789876543210
diff --git a/tests/compile-and-dump/Promote/T601a.golden b/tests/compile-and-dump/Promote/T601a.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Promote/T601a.golden
@@ -0,0 +1,73 @@
+Promote/T601a.hs:(0,0)-(0,0): Splicing declarations
+    promote
+      [d| type MyApplicative :: (Type -> Type) -> Constraint
+          
+          class Functor f => MyApplicative f where
+            ap :: f (a -> b) -> f a -> f b
+            rightSparrow :: f a -> f b -> f b
+            rightSparrow x y = ap (id <$ x) y |]
+  ======>
+    type MyApplicative :: (Type -> Type) -> Constraint
+    class Functor f => MyApplicative f where
+      ap :: f (a -> b) -> f a -> f b
+      rightSparrow :: f a -> f b -> f b
+      rightSparrow x y = ap (id <$ x) y
+    type ApSym0 :: forall (f :: Type -> Type)
+                          a
+                          b. (~>) (f ((~>) a b)) ((~>) (f a) (f b))
+    data ApSym0 :: (~>) (f ((~>) a b)) ((~>) (f a) (f b))
+      where
+        ApSym0KindInference :: SameKind (Apply ApSym0 arg) (ApSym1 arg) =>
+                               ApSym0 a0123456789876543210
+    type instance Apply @(f ((~>) a b)) @((~>) (f a) (f b)) ApSym0 a0123456789876543210 = ApSym1 a0123456789876543210
+    instance SuppressUnusedWarnings ApSym0 where
+      suppressUnusedWarnings = snd ((,) ApSym0KindInference ())
+    type ApSym1 :: forall (f :: Type -> Type) a b. f ((~>) a b)
+                                                   -> (~>) (f a) (f b)
+    data ApSym1 (a0123456789876543210 :: f ((~>) a b)) :: (~>) (f a) (f b)
+      where
+        ApSym1KindInference :: SameKind (Apply (ApSym1 a0123456789876543210) arg) (ApSym2 a0123456789876543210 arg) =>
+                               ApSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @(f a) @(f b) (ApSym1 a0123456789876543210) a0123456789876543210 = Ap a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (ApSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) ApSym1KindInference ())
+    type ApSym2 :: forall (f :: Type -> Type) a b. f ((~>) a b)
+                                                   -> f a -> f b
+    type family ApSym2 @(f :: Type
+                              -> Type) @a @b (a0123456789876543210 :: f ((~>) a b)) (a0123456789876543210 :: f a) :: f b where
+      ApSym2 a0123456789876543210 a0123456789876543210 = Ap a0123456789876543210 a0123456789876543210
+    type RightSparrowSym0 :: forall (f :: Type -> Type)
+                                    a
+                                    b. (~>) (f a) ((~>) (f b) (f b))
+    data RightSparrowSym0 :: (~>) (f a) ((~>) (f b) (f b))
+      where
+        RightSparrowSym0KindInference :: SameKind (Apply RightSparrowSym0 arg) (RightSparrowSym1 arg) =>
+                                         RightSparrowSym0 a0123456789876543210
+    type instance Apply @(f a) @((~>) (f b) (f b)) RightSparrowSym0 a0123456789876543210 = RightSparrowSym1 a0123456789876543210
+    instance SuppressUnusedWarnings RightSparrowSym0 where
+      suppressUnusedWarnings = snd ((,) RightSparrowSym0KindInference ())
+    type RightSparrowSym1 :: forall (f :: Type -> Type) a b. f a
+                                                             -> (~>) (f b) (f b)
+    data RightSparrowSym1 (a0123456789876543210 :: f a) :: (~>) (f b) (f b)
+      where
+        RightSparrowSym1KindInference :: SameKind (Apply (RightSparrowSym1 a0123456789876543210) arg) (RightSparrowSym2 a0123456789876543210 arg) =>
+                                         RightSparrowSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @(f b) @(f b) (RightSparrowSym1 a0123456789876543210) a0123456789876543210 = RightSparrow a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (RightSparrowSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) RightSparrowSym1KindInference ())
+    type RightSparrowSym2 :: forall (f :: Type -> Type) a b. f a
+                                                             -> f b -> f b
+    type family RightSparrowSym2 @(f :: Type
+                                        -> Type) @a @b (a0123456789876543210 :: f a) (a0123456789876543210 :: f b) :: f b where
+      RightSparrowSym2 a0123456789876543210 a0123456789876543210 = RightSparrow a0123456789876543210 a0123456789876543210
+    type RightSparrow_0123456789876543210 :: forall (f :: Type -> Type)
+                                                    a
+                                                    b. f a -> f b -> f b
+    type family RightSparrow_0123456789876543210 @(f :: Type
+                                                        -> Type) @a @b (a :: f a) (a :: f b) :: f b where
+      RightSparrow_0123456789876543210 @f @a @b (x :: f a) (y :: f b) = Apply (Apply ApSym0 (Apply (Apply (<$@#@$) IdSym0) x)) y
+    type PMyApplicative :: (Type -> Type) -> Constraint
+    class PMyApplicative f where
+      type family Ap (arg :: f ((~>) a b)) (arg :: f a) :: f b
+      type family RightSparrow (arg :: f a) (arg :: f b) :: f b
+      type RightSparrow a a = RightSparrow_0123456789876543210 a a
diff --git a/tests/compile-and-dump/Promote/T601a.hs b/tests/compile-and-dump/Promote/T601a.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Promote/T601a.hs
@@ -0,0 +1,14 @@
+module T601a where
+
+import Data.Kind
+import Data.Singletons.Base.TH
+import Prelude.Singletons
+
+$(promote [d|
+  type MyApplicative :: (Type -> Type) -> Constraint
+  class Functor f => MyApplicative f where
+    ap :: f (a -> b) -> f a -> f b
+
+    rightSparrow :: f a -> f b -> f b
+    rightSparrow x y = ap (id <$ x) y
+  |])
diff --git a/tests/compile-and-dump/Promote/T605.golden b/tests/compile-and-dump/Promote/T605.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Promote/T605.golden
@@ -0,0 +1,39 @@
+Promote/T605.hs:(0,0)-(0,0): Splicing declarations
+    promoteOnly
+      [d| type Traversable' :: (Type -> Type) -> Constraint
+          
+          class (Functor t, Foldable t) => Traversable' t where
+            traverse' :: Applicative f => (a -> f b) -> t a -> t (f b) |]
+  ======>
+    type Traverse'Sym0 :: forall (t :: Type -> Type)
+                                 a
+                                 f
+                                 b. (~>) ((~>) a (f b)) ((~>) (t a) (t (f b)))
+    data Traverse'Sym0 :: (~>) ((~>) a (f b)) ((~>) (t a) (t (f b)))
+      where
+        Traverse'Sym0KindInference :: SameKind (Apply Traverse'Sym0 arg) (Traverse'Sym1 arg) =>
+                                      Traverse'Sym0 a0123456789876543210
+    type instance Apply @((~>) a (f b)) @((~>) (t a) (t (f b))) Traverse'Sym0 a0123456789876543210 = Traverse'Sym1 a0123456789876543210
+    instance SuppressUnusedWarnings Traverse'Sym0 where
+      suppressUnusedWarnings = snd ((,) Traverse'Sym0KindInference ())
+    type Traverse'Sym1 :: forall (t :: Type -> Type)
+                                 a
+                                 f
+                                 b. (~>) a (f b) -> (~>) (t a) (t (f b))
+    data Traverse'Sym1 (a0123456789876543210 :: (~>) a (f b)) :: (~>) (t a) (t (f b))
+      where
+        Traverse'Sym1KindInference :: SameKind (Apply (Traverse'Sym1 a0123456789876543210) arg) (Traverse'Sym2 a0123456789876543210 arg) =>
+                                      Traverse'Sym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @(t a) @(t (f b)) (Traverse'Sym1 a0123456789876543210) a0123456789876543210 = Traverse' a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Traverse'Sym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) Traverse'Sym1KindInference ())
+    type Traverse'Sym2 :: forall (t :: Type -> Type)
+                                 a
+                                 f
+                                 b. (~>) a (f b) -> t a -> t (f b)
+    type family Traverse'Sym2 @(t :: Type
+                                     -> Type) @a @f @b (a0123456789876543210 :: (~>) a (f b)) (a0123456789876543210 :: t a) :: t (f b) where
+      Traverse'Sym2 a0123456789876543210 a0123456789876543210 = Traverse' a0123456789876543210 a0123456789876543210
+    type PTraversable' :: (Type -> Type) -> Constraint
+    class PTraversable' t where
+      type family Traverse' (arg :: (~>) a (f b)) (arg :: t a) :: t (f b)
diff --git a/tests/compile-and-dump/Promote/T605.hs b/tests/compile-and-dump/Promote/T605.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Promote/T605.hs
@@ -0,0 +1,11 @@
+module T605 where
+
+import Data.Kind
+import Data.Singletons.Base.TH
+import Prelude.Singletons
+
+$(promoteOnly [d|
+  type Traversable' :: (Type -> Type) -> Constraint
+  class (Functor t, Foldable t) => Traversable' t where
+    traverse' :: Applicative f => (a -> f b) -> t a -> t (f b)
+  |])
diff --git a/tests/compile-and-dump/Promote/T613.golden b/tests/compile-and-dump/Promote/T613.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Promote/T613.golden
@@ -0,0 +1,31 @@
+Promote/T613.hs:(0,0)-(0,0): Splicing declarations
+    promote
+      [d| f :: forall k (a :: k). Proxy a -> Proxy a
+          f x
+            = y
+            where
+                y = x |]
+  ======>
+    f :: forall k (a :: k). Proxy a -> Proxy a
+    f x
+      = y
+      where
+          y = x
+    type family Let0123456789876543210YSym0 k0123456789876543210 (a0123456789876543210 :: k0123456789876543210) (x0123456789876543210 :: Proxy a0123456789876543210) where
+      Let0123456789876543210YSym0 k0123456789876543210 a0123456789876543210 x0123456789876543210 = Let0123456789876543210Y k0123456789876543210 a0123456789876543210 x0123456789876543210
+    type family Let0123456789876543210Y k0123456789876543210 (a0123456789876543210 :: k0123456789876543210) (x0123456789876543210 :: Proxy a0123456789876543210) where
+      Let0123456789876543210Y k a x = x
+    type FSym0 :: forall k (a :: k). (~>) (Proxy a) (Proxy a)
+    data FSym0 :: (~>) (Proxy a) (Proxy a)
+      where
+        FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
+                              FSym0 a0123456789876543210
+    type instance Apply @(Proxy a) @(Proxy a) FSym0 a0123456789876543210 = F a0123456789876543210
+    instance SuppressUnusedWarnings FSym0 where
+      suppressUnusedWarnings = snd ((,) FSym0KindInference ())
+    type FSym1 :: forall k (a :: k). Proxy a -> Proxy a
+    type family FSym1 @k @(a :: k) (a0123456789876543210 :: Proxy a) :: Proxy a where
+      FSym1 a0123456789876543210 = F a0123456789876543210
+    type F :: forall k (a :: k). Proxy a -> Proxy a
+    type family F @k @(a :: k) (a :: Proxy a) :: Proxy a where
+      F @k @a (x :: Proxy a) = Let0123456789876543210YSym0 k a x
diff --git a/tests/compile-and-dump/Promote/T613.hs b/tests/compile-and-dump/Promote/T613.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Promote/T613.hs
@@ -0,0 +1,12 @@
+module T613 where
+
+import Data.Proxy
+import Data.Proxy.Singletons
+import Data.Singletons.TH
+
+$(promote [d|
+  f :: forall k (a :: k). Proxy a -> Proxy a
+  f x = y
+    where
+      y = x
+  |])
diff --git a/tests/compile-and-dump/Singletons/AsPattern.golden b/tests/compile-and-dump/Singletons/AsPattern.golden
--- a/tests/compile-and-dump/Singletons/AsPattern.golden
+++ b/tests/compile-and-dump/Singletons/AsPattern.golden
@@ -19,7 +19,7 @@
           data Baz = Baz Nat Nat Nat |]
   ======>
     maybePlus :: Maybe Nat -> Maybe Nat
-    maybePlus (Just n) = Just ((plus (Succ Zero)) n)
+    maybePlus (Just n) = Just (plus (Succ Zero) n)
     maybePlus p@Nothing = p
     bar :: Maybe Nat -> Maybe Nat
     bar x@(Just _) = x
@@ -39,25 +39,25 @@
       where
         BazSym0KindInference :: SameKind (Apply BazSym0 arg) (BazSym1 arg) =>
                                 BazSym0 a0123456789876543210
-    type instance Apply BazSym0 a0123456789876543210 = BazSym1 a0123456789876543210
+    type instance Apply @Nat @((~>) Nat ((~>) Nat Baz)) BazSym0 a0123456789876543210 = BazSym1 a0123456789876543210
     instance SuppressUnusedWarnings BazSym0 where
-      suppressUnusedWarnings = snd (((,) BazSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BazSym0KindInference ())
     type BazSym1 :: Nat -> (~>) Nat ((~>) Nat Baz)
     data BazSym1 (a0123456789876543210 :: Nat) :: (~>) Nat ((~>) Nat Baz)
       where
         BazSym1KindInference :: SameKind (Apply (BazSym1 a0123456789876543210) arg) (BazSym2 a0123456789876543210 arg) =>
                                 BazSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (BazSym1 a0123456789876543210) a0123456789876543210 = BazSym2 a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @((~>) Nat Baz) (BazSym1 a0123456789876543210) a0123456789876543210 = BazSym2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (BazSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BazSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) BazSym1KindInference ())
     type BazSym2 :: Nat -> Nat -> (~>) Nat Baz
     data BazSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: (~>) Nat Baz
       where
         BazSym2KindInference :: SameKind (Apply (BazSym2 a0123456789876543210 a0123456789876543210) arg) (BazSym3 a0123456789876543210 a0123456789876543210 arg) =>
                                 BazSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (BazSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = Baz a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Baz (BazSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = Baz a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (BazSym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BazSym2KindInference) ())
+      suppressUnusedWarnings = snd ((,) BazSym2KindInference ())
     type BazSym3 :: Nat -> Nat -> Nat -> Baz
     type family BazSym3 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Baz where
       BazSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = Baz a0123456789876543210 a0123456789876543210 a0123456789876543210
@@ -65,109 +65,29 @@
       Let0123456789876543210PSym0 = Let0123456789876543210P
     type family Let0123456789876543210P where
       Let0123456789876543210P = NilSym0
-    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210PSym0KindInference :: SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>
-                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210
-    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210PSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210PSym0KindInference) ())
-    type family Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 where
-      Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210
-    type family Let0123456789876543210P wild_0123456789876543210 where
+    type family Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 where
+      Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210
+    type family Let0123456789876543210P wild_01234567898765432100123456789876543210 where
       Let0123456789876543210P wild_0123456789876543210 = Apply (Apply (:@#@$) wild_0123456789876543210) NilSym0
-    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210PSym0KindInference :: SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>
-                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210
-    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210PSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210PSym0KindInference) ())
-    data Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210PSym1KindInference :: SameKind (Apply (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) arg) (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 arg) =>
-                                                    Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    type instance Apply (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) wild_01234567898765432100123456789876543210 = Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210PSym1KindInference) ())
-    data Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210PSym2KindInference :: SameKind (Apply (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210) arg) (Let0123456789876543210PSym3 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 arg) =>
-                                                    Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    type instance Apply (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210) wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210PSym2KindInference) ())
-    type family Let0123456789876543210PSym3 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 where
-      Let0123456789876543210PSym3 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    type family Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 where
+    type family Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 where
+      Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
+    type family Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 where
       Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 = Apply (Apply (:@#@$) wild_0123456789876543210) (Apply (Apply (:@#@$) wild_0123456789876543210) wild_0123456789876543210)
-    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210PSym0KindInference :: SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>
-                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210
-    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210PSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210PSym0KindInference) ())
-    data Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210PSym1KindInference :: SameKind (Apply (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) arg) (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 arg) =>
-                                                    Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    type instance Apply (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210PSym1KindInference) ())
-    type family Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 where
-      Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    type family Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 where
+    type family Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 where
+      Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
+    type family Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 where
       Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 = Apply (Apply Tuple2Sym0 wild_0123456789876543210) wild_0123456789876543210
     type family Let0123456789876543210PSym0 where
       Let0123456789876543210PSym0 = Let0123456789876543210P
     type family Let0123456789876543210P where
       Let0123456789876543210P = NothingSym0
-    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210PSym0KindInference :: SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>
-                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210
-    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210PSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210PSym0KindInference) ())
-    data Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210PSym1KindInference :: SameKind (Apply (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) arg) (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 arg) =>
-                                                    Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    type instance Apply (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) wild_01234567898765432100123456789876543210 = Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210PSym1KindInference) ())
-    data Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210PSym2KindInference :: SameKind (Apply (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210) arg) (Let0123456789876543210PSym3 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 arg) =>
-                                                    Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    type instance Apply (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210) wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210PSym2KindInference) ())
-    type family Let0123456789876543210PSym3 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 where
-      Let0123456789876543210PSym3 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
-    type family Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 where
+    type family Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 where
+      Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210
+    type family Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 where
       Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 = Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789876543210) wild_0123456789876543210) wild_0123456789876543210)
-    data Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210XSym0KindInference :: SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>
-                                                    Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210
-    type instance Apply Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210X wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210XSym0KindInference) ())
-    type family Let0123456789876543210XSym1 wild_01234567898765432100123456789876543210 where
-      Let0123456789876543210XSym1 wild_01234567898765432100123456789876543210 = Let0123456789876543210X wild_01234567898765432100123456789876543210
-    type family Let0123456789876543210X wild_0123456789876543210 where
+    type family Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210 where
+      Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210X wild_01234567898765432100123456789876543210
+    type family Let0123456789876543210X wild_01234567898765432100123456789876543210 where
       Let0123456789876543210X wild_0123456789876543210 = Apply JustSym0 wild_0123456789876543210
     type family Let0123456789876543210PSym0 where
       Let0123456789876543210PSym0 = Let0123456789876543210P
@@ -178,9 +98,9 @@
       where
         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
                                 FooSym0 a0123456789876543210
-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210
+    type instance Apply @[Nat] @[Nat] FooSym0 a0123456789876543210 = Foo a0123456789876543210
     instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
     type FooSym1 :: [Nat] -> [Nat]
     type family FooSym1 (a0123456789876543210 :: [Nat]) :: [Nat] where
       FooSym1 a0123456789876543210 = Foo a0123456789876543210
@@ -189,9 +109,10 @@
       where
         TupSym0KindInference :: SameKind (Apply TupSym0 arg) (TupSym1 arg) =>
                                 TupSym0 a0123456789876543210
-    type instance Apply TupSym0 a0123456789876543210 = Tup a0123456789876543210
+    type instance Apply @(Nat, Nat) @(Nat,
+                                      Nat) TupSym0 a0123456789876543210 = Tup a0123456789876543210
     instance SuppressUnusedWarnings TupSym0 where
-      suppressUnusedWarnings = snd (((,) TupSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) TupSym0KindInference ())
     type TupSym1 :: (Nat, Nat) -> (Nat, Nat)
     type family TupSym1 (a0123456789876543210 :: (Nat, Nat)) :: (Nat,
                                                                  Nat) where
@@ -201,9 +122,9 @@
       where
         Baz_Sym0KindInference :: SameKind (Apply Baz_Sym0 arg) (Baz_Sym1 arg) =>
                                  Baz_Sym0 a0123456789876543210
-    type instance Apply Baz_Sym0 a0123456789876543210 = Baz_ a0123456789876543210
+    type instance Apply @(Maybe Baz) @(Maybe Baz) Baz_Sym0 a0123456789876543210 = Baz_ a0123456789876543210
     instance SuppressUnusedWarnings Baz_Sym0 where
-      suppressUnusedWarnings = snd (((,) Baz_Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Baz_Sym0KindInference ())
     type Baz_Sym1 :: Maybe Baz -> Maybe Baz
     type family Baz_Sym1 (a0123456789876543210 :: Maybe Baz) :: Maybe Baz where
       Baz_Sym1 a0123456789876543210 = Baz_ a0123456789876543210
@@ -212,9 +133,9 @@
       where
         BarSym0KindInference :: SameKind (Apply BarSym0 arg) (BarSym1 arg) =>
                                 BarSym0 a0123456789876543210
-    type instance Apply BarSym0 a0123456789876543210 = Bar a0123456789876543210
+    type instance Apply @(Maybe Nat) @(Maybe Nat) BarSym0 a0123456789876543210 = Bar a0123456789876543210
     instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BarSym0KindInference ())
     type BarSym1 :: Maybe Nat -> Maybe Nat
     type family BarSym1 (a0123456789876543210 :: Maybe Nat) :: Maybe Nat where
       BarSym1 a0123456789876543210 = Bar a0123456789876543210
@@ -223,62 +144,60 @@
       where
         MaybePlusSym0KindInference :: SameKind (Apply MaybePlusSym0 arg) (MaybePlusSym1 arg) =>
                                       MaybePlusSym0 a0123456789876543210
-    type instance Apply MaybePlusSym0 a0123456789876543210 = MaybePlus a0123456789876543210
+    type instance Apply @(Maybe Nat) @(Maybe Nat) MaybePlusSym0 a0123456789876543210 = MaybePlus a0123456789876543210
     instance SuppressUnusedWarnings MaybePlusSym0 where
-      suppressUnusedWarnings = snd (((,) MaybePlusSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MaybePlusSym0KindInference ())
     type MaybePlusSym1 :: Maybe Nat -> Maybe Nat
     type family MaybePlusSym1 (a0123456789876543210 :: Maybe Nat) :: Maybe Nat where
       MaybePlusSym1 a0123456789876543210 = MaybePlus a0123456789876543210
     type Foo :: [Nat] -> [Nat]
     type family Foo (a :: [Nat]) :: [Nat] where
       Foo '[] = Let0123456789876543210PSym0
-      Foo '[wild_0123456789876543210] = Let0123456789876543210PSym1 wild_0123456789876543210
-      Foo ('(:) wild_0123456789876543210 ('(:) wild_0123456789876543210 wild_0123456789876543210)) = Let0123456789876543210PSym3 wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210
+      Foo '[wild_0123456789876543210] = Let0123456789876543210PSym0 wild_0123456789876543210
+      Foo ('(:) wild_0123456789876543210 ('(:) wild_0123456789876543210 wild_0123456789876543210)) = Let0123456789876543210PSym0 wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210
     type Tup :: (Nat, Nat) -> (Nat, Nat)
     type family Tup (a :: (Nat, Nat)) :: (Nat, Nat) where
       Tup '(wild_0123456789876543210,
-            wild_0123456789876543210) = Let0123456789876543210PSym2 wild_0123456789876543210 wild_0123456789876543210
+            wild_0123456789876543210) = Let0123456789876543210PSym0 wild_0123456789876543210 wild_0123456789876543210
     type Baz_ :: Maybe Baz -> Maybe Baz
     type family Baz_ (a :: Maybe Baz) :: Maybe Baz where
       Baz_ 'Nothing = Let0123456789876543210PSym0
-      Baz_ ('Just (Baz wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210)) = Let0123456789876543210PSym3 wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210
+      Baz_ ('Just (Baz wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210)) = Let0123456789876543210PSym0 wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210
     type Bar :: Maybe Nat -> Maybe Nat
     type family Bar (a :: Maybe Nat) :: Maybe Nat where
-      Bar ('Just wild_0123456789876543210) = Let0123456789876543210XSym1 wild_0123456789876543210
+      Bar ('Just wild_0123456789876543210) = Let0123456789876543210XSym0 wild_0123456789876543210
       Bar 'Nothing = NothingSym0
     type MaybePlus :: Maybe Nat -> Maybe Nat
     type family MaybePlus (a :: Maybe Nat) :: Maybe Nat where
       MaybePlus ('Just n) = Apply JustSym0 (Apply (Apply PlusSym0 (Apply SuccSym0 ZeroSym0)) n)
       MaybePlus 'Nothing = Let0123456789876543210PSym0
     sFoo ::
-      forall (t :: [Nat]). Sing t -> Sing (Apply FooSym0 t :: [Nat])
+      (forall (t :: [Nat]). Sing t -> Sing (Foo t :: [Nat]) :: Type)
     sTup ::
-      forall (t :: (Nat, Nat)). Sing t
-                                -> Sing (Apply TupSym0 t :: (Nat, Nat))
+      (forall (t :: (Nat, Nat)).
+       Sing t -> Sing (Tup t :: (Nat, Nat)) :: Type)
     sBaz_ ::
-      forall (t :: Maybe Baz). Sing t
-                               -> Sing (Apply Baz_Sym0 t :: Maybe Baz)
+      (forall (t :: Maybe Baz).
+       Sing t -> Sing (Baz_ t :: Maybe Baz) :: Type)
     sBar ::
-      forall (t :: Maybe Nat). Sing t
-                               -> Sing (Apply BarSym0 t :: Maybe Nat)
+      (forall (t :: Maybe Nat).
+       Sing t -> Sing (Bar t :: Maybe Nat) :: Type)
     sMaybePlus ::
-      forall (t :: Maybe Nat). Sing t
-                               -> Sing (Apply MaybePlusSym0 t :: Maybe Nat)
+      (forall (t :: Maybe Nat).
+       Sing t -> Sing (MaybePlus t :: Maybe Nat) :: Type)
     sFoo SNil
       = let
-          sP :: Sing @_ Let0123456789876543210PSym0
+          sP :: Sing @_ Let0123456789876543210P
           sP = SNil
         in sP
     sFoo
       (SCons (sWild_0123456789876543210 :: Sing wild_0123456789876543210)
              SNil)
       = let
-          sP ::
-            Sing @_ (Let0123456789876543210PSym1 wild_0123456789876543210)
+          sP :: Sing @_ (Let0123456789876543210P wild_0123456789876543210)
           sP
-            = (applySing
-                 ((applySing ((singFun2 @(:@#@$)) SCons))
-                    sWild_0123456789876543210))
+            = applySing
+                (applySing (singFun2 @(:@#@$) SCons) sWild_0123456789876543210)
                 SNil
         in sP
     sFoo
@@ -287,14 +206,12 @@
                     (sWild_0123456789876543210 :: Sing wild_0123456789876543210)))
       = let
           sP ::
-            Sing @_ (Let0123456789876543210PSym3 wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210)
+            Sing @_ (Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210)
           sP
-            = (applySing
-                 ((applySing ((singFun2 @(:@#@$)) SCons))
-                    sWild_0123456789876543210))
-                ((applySing
-                    ((applySing ((singFun2 @(:@#@$)) SCons))
-                       sWild_0123456789876543210))
+            = applySing
+                (applySing (singFun2 @(:@#@$) SCons) sWild_0123456789876543210)
+                (applySing
+                   (applySing (singFun2 @(:@#@$) SCons) sWild_0123456789876543210)
                    sWild_0123456789876543210)
         in sP
     sTup
@@ -302,16 +219,16 @@
                (sWild_0123456789876543210 :: Sing wild_0123456789876543210))
       = let
           sP ::
-            Sing @_ (Let0123456789876543210PSym2 wild_0123456789876543210 wild_0123456789876543210)
+            Sing @_ (Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210)
           sP
-            = (applySing
-                 ((applySing ((singFun2 @Tuple2Sym0) STuple2))
-                    sWild_0123456789876543210))
+            = applySing
+                (applySing
+                   (singFun2 @Tuple2Sym0 STuple2) sWild_0123456789876543210)
                 sWild_0123456789876543210
         in sP
     sBaz_ SNothing
       = let
-          sP :: Sing @_ Let0123456789876543210PSym0
+          sP :: Sing @_ Let0123456789876543210P
           sP = SNothing
         in sP
     sBaz_
@@ -320,46 +237,46 @@
                    (sWild_0123456789876543210 :: Sing wild_0123456789876543210)))
       = let
           sP ::
-            Sing @_ (Let0123456789876543210PSym3 wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210)
+            Sing @_ (Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210)
           sP
-            = (applySing ((singFun1 @JustSym0) SJust))
-                ((applySing
-                    ((applySing
-                        ((applySing ((singFun3 @BazSym0) SBaz)) sWild_0123456789876543210))
-                       sWild_0123456789876543210))
+            = applySing
+                (singFun1 @JustSym0 SJust)
+                (applySing
+                   (applySing
+                      (applySing (singFun3 @BazSym0 SBaz) sWild_0123456789876543210)
+                      sWild_0123456789876543210)
                    sWild_0123456789876543210)
         in sP
     sBar
       (SJust (sWild_0123456789876543210 :: Sing wild_0123456789876543210))
       = let
-          sX ::
-            Sing @_ (Let0123456789876543210XSym1 wild_0123456789876543210)
-          sX
-            = (applySing ((singFun1 @JustSym0) SJust))
-                sWild_0123456789876543210
+          sX :: Sing @_ (Let0123456789876543210X wild_0123456789876543210)
+          sX = applySing (singFun1 @JustSym0 SJust) sWild_0123456789876543210
         in sX
     sBar SNothing = SNothing
     sMaybePlus (SJust (sN :: Sing n))
-      = (applySing ((singFun1 @JustSym0) SJust))
-          ((applySing
-              ((applySing ((singFun2 @PlusSym0) sPlus))
-                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
+      = applySing
+          (singFun1 @JustSym0 SJust)
+          (applySing
+             (applySing
+                (singFun2 @PlusSym0 sPlus)
+                (applySing (singFun1 @SuccSym0 SSucc) SZero))
              sN)
     sMaybePlus SNothing
       = let
-          sP :: Sing @_ Let0123456789876543210PSym0
+          sP :: Sing @_ Let0123456789876543210P
           sP = SNothing
         in sP
     instance SingI (FooSym0 :: (~>) [Nat] [Nat]) where
-      sing = (singFun1 @FooSym0) sFoo
+      sing = singFun1 @FooSym0 sFoo
     instance SingI (TupSym0 :: (~>) (Nat, Nat) (Nat, Nat)) where
-      sing = (singFun1 @TupSym0) sTup
+      sing = singFun1 @TupSym0 sTup
     instance SingI (Baz_Sym0 :: (~>) (Maybe Baz) (Maybe Baz)) where
-      sing = (singFun1 @Baz_Sym0) sBaz_
+      sing = singFun1 @Baz_Sym0 sBaz_
     instance SingI (BarSym0 :: (~>) (Maybe Nat) (Maybe Nat)) where
-      sing = (singFun1 @BarSym0) sBar
+      sing = singFun1 @BarSym0 sBar
     instance SingI (MaybePlusSym0 :: (~>) (Maybe Nat) (Maybe Nat)) where
-      sing = (singFun1 @MaybePlusSym0) sMaybePlus
+      sing = singFun1 @MaybePlusSym0 sMaybePlus
     data SBaz :: Baz -> Type
       where
         SBaz :: forall (n :: Nat) (n :: Nat) (n :: Nat).
@@ -367,40 +284,37 @@
     type instance Sing @Baz = SBaz
     instance SingKind Baz where
       type Demote Baz = Baz
-      fromSing (SBaz b b b)
-        = ((Baz (fromSing b)) (fromSing b)) (fromSing b)
+      fromSing (SBaz b b b) = Baz (fromSing b) (fromSing b) (fromSing b)
       toSing (Baz (b :: Demote Nat) (b :: Demote Nat) (b :: Demote Nat))
-        = case
-              (((,,) (toSing b :: SomeSing Nat)) (toSing b :: SomeSing Nat))
-                (toSing b :: SomeSing Nat)
-          of
-            (,,) (SomeSing c) (SomeSing c) (SomeSing c)
-              -> SomeSing (((SBaz c) c) c)
+        = (\cases
+             (SomeSing c) (SomeSing c) (SomeSing c) -> SomeSing (SBaz c c c))
+            (toSing b :: SomeSing Nat) (toSing b :: SomeSing Nat)
+            (toSing b :: SomeSing Nat)
     instance (SingI n, SingI n, SingI n) =>
              SingI (Baz (n :: Nat) (n :: Nat) (n :: Nat)) where
-      sing = ((SBaz sing) sing) sing
+      sing = SBaz sing sing sing
     instance (SingI n, SingI n) =>
              SingI1 (Baz (n :: Nat) (n :: Nat)) where
-      liftSing = (SBaz sing) sing
+      liftSing = SBaz sing sing
     instance SingI n => SingI2 (Baz (n :: Nat)) where
       liftSing2 = SBaz sing
     instance SingI (BazSym0 :: (~>) Nat ((~>) Nat ((~>) Nat Baz))) where
-      sing = (singFun3 @BazSym0) SBaz
+      sing = singFun3 @BazSym0 SBaz
     instance SingI d =>
              SingI (BazSym1 (d :: Nat) :: (~>) Nat ((~>) Nat Baz)) where
-      sing = (singFun2 @(BazSym1 (d :: Nat))) (SBaz (sing @d))
+      sing = singFun2 @(BazSym1 (d :: Nat)) (SBaz (sing @d))
     instance SingI1 (BazSym1 :: Nat -> (~>) Nat ((~>) Nat Baz)) where
       liftSing (s :: Sing (d :: Nat))
-        = (singFun2 @(BazSym1 (d :: Nat))) (SBaz s)
+        = singFun2 @(BazSym1 (d :: Nat)) (SBaz s)
     instance (SingI d, SingI d) =>
              SingI (BazSym2 (d :: Nat) (d :: Nat) :: (~>) Nat Baz) where
       sing
-        = (singFun1 @(BazSym2 (d :: Nat) (d :: Nat)))
-            ((SBaz (sing @d)) (sing @d))
+        = singFun1
+            @(BazSym2 (d :: Nat) (d :: Nat)) (SBaz (sing @d) (sing @d))
     instance SingI d =>
              SingI1 (BazSym2 (d :: Nat) :: Nat -> (~>) Nat Baz) where
       liftSing (s :: Sing (d :: Nat))
-        = (singFun1 @(BazSym2 (d :: Nat) (d :: Nat))) ((SBaz (sing @d)) s)
+        = singFun1 @(BazSym2 (d :: Nat) (d :: Nat)) (SBaz (sing @d) s)
     instance SingI2 (BazSym2 :: Nat -> Nat -> (~>) Nat Baz) where
       liftSing2 (s :: Sing (d :: Nat)) (s :: Sing (d :: Nat))
-        = (singFun1 @(BazSym2 (d :: Nat) (d :: Nat))) ((SBaz s) s)
+        = singFun1 @(BazSym2 (d :: Nat) (d :: Nat)) (SBaz s s)
diff --git a/tests/compile-and-dump/Singletons/BadBoundedDeriving.golden b/tests/compile-and-dump/Singletons/BadBoundedDeriving.golden
--- a/tests/compile-and-dump/Singletons/BadBoundedDeriving.golden
+++ b/tests/compile-and-dump/Singletons/BadBoundedDeriving.golden
@@ -1,5 +1,5 @@
 
-Singletons/BadBoundedDeriving.hs:0:0: error:
+Singletons/BadBoundedDeriving.hs:0:0: error: [GHC-39584]
     Can't derive Bounded instance for Foo_0 a_1.
   |
 5 | $(singletons [d|
diff --git a/tests/compile-and-dump/Singletons/BadEnumDeriving.golden b/tests/compile-and-dump/Singletons/BadEnumDeriving.golden
--- a/tests/compile-and-dump/Singletons/BadEnumDeriving.golden
+++ b/tests/compile-and-dump/Singletons/BadEnumDeriving.golden
@@ -1,5 +1,5 @@
 
-Singletons/BadEnumDeriving.hs:0:0: error:
+Singletons/BadEnumDeriving.hs:0:0: error: [GHC-39584]
     Can't derive Enum instance for Foo_0 a_1.
   |
 5 | $(singletons [d|
diff --git a/tests/compile-and-dump/Singletons/BoundedDeriving.golden b/tests/compile-and-dump/Singletons/BoundedDeriving.golden
--- a/tests/compile-and-dump/Singletons/BoundedDeriving.golden
+++ b/tests/compile-and-dump/Singletons/BoundedDeriving.golden
@@ -54,114 +54,82 @@
       where
         Foo3Sym0KindInference :: SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>
                                  Foo3Sym0 a0123456789876543210
-    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210
+    type instance Apply @a @(Foo3 a) Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210
     instance SuppressUnusedWarnings Foo3Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo3Sym0KindInference ())
     type Foo3Sym1 :: forall a. a -> Foo3 a
-    type family Foo3Sym1 (a0123456789876543210 :: a) :: Foo3 a where
+    type family Foo3Sym1 @a (a0123456789876543210 :: a) :: Foo3 a where
       Foo3Sym1 a0123456789876543210 = Foo3 a0123456789876543210
-    type Foo41Sym0 :: forall (a :: Type)
-                             (b :: Type). Foo4 (a :: Type) (b :: Type)
-    type family Foo41Sym0 :: Foo4 (a :: Type) (b :: Type) where
+    type Foo41Sym0 :: forall (a :: Type) (b :: Type). Foo4 a b
+    type family Foo41Sym0 @(a :: Type) @(b :: Type) :: Foo4 a b where
       Foo41Sym0 = Foo41
-    type Foo42Sym0 :: forall (a :: Type)
-                             (b :: Type). Foo4 (a :: Type) (b :: Type)
-    type family Foo42Sym0 :: Foo4 (a :: Type) (b :: Type) where
+    type Foo42Sym0 :: forall (a :: Type) (b :: Type). Foo4 a b
+    type family Foo42Sym0 @(a :: Type) @(b :: Type) :: Foo4 a b where
       Foo42Sym0 = Foo42
     type PairSym0 :: (~>) Bool ((~>) Bool Pair)
     data PairSym0 :: (~>) Bool ((~>) Bool Pair)
       where
         PairSym0KindInference :: SameKind (Apply PairSym0 arg) (PairSym1 arg) =>
                                  PairSym0 a0123456789876543210
-    type instance Apply PairSym0 a0123456789876543210 = PairSym1 a0123456789876543210
+    type instance Apply @Bool @((~>) Bool Pair) PairSym0 a0123456789876543210 = PairSym1 a0123456789876543210
     instance SuppressUnusedWarnings PairSym0 where
-      suppressUnusedWarnings = snd (((,) PairSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) PairSym0KindInference ())
     type PairSym1 :: Bool -> (~>) Bool Pair
     data PairSym1 (a0123456789876543210 :: Bool) :: (~>) Bool Pair
       where
         PairSym1KindInference :: SameKind (Apply (PairSym1 a0123456789876543210) arg) (PairSym2 a0123456789876543210 arg) =>
                                  PairSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (PairSym1 a0123456789876543210) a0123456789876543210 = Pair a0123456789876543210 a0123456789876543210
+    type instance Apply @Bool @Pair (PairSym1 a0123456789876543210) a0123456789876543210 = Pair a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (PairSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) PairSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) PairSym1KindInference ())
     type PairSym2 :: Bool -> Bool -> Pair
     type family PairSym2 (a0123456789876543210 :: Bool) (a0123456789876543210 :: Bool) :: Pair where
       PairSym2 a0123456789876543210 a0123456789876543210 = Pair a0123456789876543210 a0123456789876543210
     type MinBound_0123456789876543210 :: Foo1
     type family MinBound_0123456789876543210 :: Foo1 where
       MinBound_0123456789876543210 = Foo1Sym0
-    type MinBound_0123456789876543210Sym0 :: Foo1
-    type family MinBound_0123456789876543210Sym0 :: Foo1 where
-      MinBound_0123456789876543210Sym0 = MinBound_0123456789876543210
     type MaxBound_0123456789876543210 :: Foo1
     type family MaxBound_0123456789876543210 :: Foo1 where
       MaxBound_0123456789876543210 = Foo1Sym0
-    type MaxBound_0123456789876543210Sym0 :: Foo1
-    type family MaxBound_0123456789876543210Sym0 :: Foo1 where
-      MaxBound_0123456789876543210Sym0 = MaxBound_0123456789876543210
     instance PBounded Foo1 where
-      type MinBound = MinBound_0123456789876543210Sym0
-      type MaxBound = MaxBound_0123456789876543210Sym0
+      type MinBound = MinBound_0123456789876543210
+      type MaxBound = MaxBound_0123456789876543210
     type MinBound_0123456789876543210 :: Foo2
     type family MinBound_0123456789876543210 :: Foo2 where
       MinBound_0123456789876543210 = ASym0
-    type MinBound_0123456789876543210Sym0 :: Foo2
-    type family MinBound_0123456789876543210Sym0 :: Foo2 where
-      MinBound_0123456789876543210Sym0 = MinBound_0123456789876543210
     type MaxBound_0123456789876543210 :: Foo2
     type family MaxBound_0123456789876543210 :: Foo2 where
       MaxBound_0123456789876543210 = ESym0
-    type MaxBound_0123456789876543210Sym0 :: Foo2
-    type family MaxBound_0123456789876543210Sym0 :: Foo2 where
-      MaxBound_0123456789876543210Sym0 = MaxBound_0123456789876543210
     instance PBounded Foo2 where
-      type MinBound = MinBound_0123456789876543210Sym0
-      type MaxBound = MaxBound_0123456789876543210Sym0
-    type MinBound_0123456789876543210 :: Foo3 a
-    type family MinBound_0123456789876543210 :: Foo3 a where
-      MinBound_0123456789876543210 = Apply Foo3Sym0 MinBoundSym0
-    type MinBound_0123456789876543210Sym0 :: Foo3 a
-    type family MinBound_0123456789876543210Sym0 :: Foo3 a where
-      MinBound_0123456789876543210Sym0 = MinBound_0123456789876543210
-    type MaxBound_0123456789876543210 :: Foo3 a
-    type family MaxBound_0123456789876543210 :: Foo3 a where
-      MaxBound_0123456789876543210 = Apply Foo3Sym0 MaxBoundSym0
-    type MaxBound_0123456789876543210Sym0 :: Foo3 a
-    type family MaxBound_0123456789876543210Sym0 :: Foo3 a where
-      MaxBound_0123456789876543210Sym0 = MaxBound_0123456789876543210
+      type MinBound = MinBound_0123456789876543210
+      type MaxBound = MaxBound_0123456789876543210
+    type MinBound_0123456789876543210 :: forall a. Foo3 a
+    type family MinBound_0123456789876543210 @a :: Foo3 a where
+      MinBound_0123456789876543210 @a = Apply Foo3Sym0 MinBoundSym0
+    type MaxBound_0123456789876543210 :: forall a. Foo3 a
+    type family MaxBound_0123456789876543210 @a :: Foo3 a where
+      MaxBound_0123456789876543210 @a = Apply Foo3Sym0 MaxBoundSym0
     instance PBounded (Foo3 a) where
-      type MinBound = MinBound_0123456789876543210Sym0
-      type MaxBound = MaxBound_0123456789876543210Sym0
-    type MinBound_0123456789876543210 :: Foo4 a b
-    type family MinBound_0123456789876543210 :: Foo4 a b where
-      MinBound_0123456789876543210 = Foo41Sym0
-    type MinBound_0123456789876543210Sym0 :: Foo4 a b
-    type family MinBound_0123456789876543210Sym0 :: Foo4 a b where
-      MinBound_0123456789876543210Sym0 = MinBound_0123456789876543210
-    type MaxBound_0123456789876543210 :: Foo4 a b
-    type family MaxBound_0123456789876543210 :: Foo4 a b where
-      MaxBound_0123456789876543210 = Foo42Sym0
-    type MaxBound_0123456789876543210Sym0 :: Foo4 a b
-    type family MaxBound_0123456789876543210Sym0 :: Foo4 a b where
-      MaxBound_0123456789876543210Sym0 = MaxBound_0123456789876543210
+      type MinBound = MinBound_0123456789876543210
+      type MaxBound = MaxBound_0123456789876543210
+    type MinBound_0123456789876543210 :: forall a b. Foo4 a b
+    type family MinBound_0123456789876543210 @a @b :: Foo4 a b where
+      MinBound_0123456789876543210 @a @b = Foo41Sym0
+    type MaxBound_0123456789876543210 :: forall a b. Foo4 a b
+    type family MaxBound_0123456789876543210 @a @b :: Foo4 a b where
+      MaxBound_0123456789876543210 @a @b = Foo42Sym0
     instance PBounded (Foo4 a b) where
-      type MinBound = MinBound_0123456789876543210Sym0
-      type MaxBound = MaxBound_0123456789876543210Sym0
+      type MinBound = MinBound_0123456789876543210
+      type MaxBound = MaxBound_0123456789876543210
     type MinBound_0123456789876543210 :: Pair
     type family MinBound_0123456789876543210 :: Pair where
       MinBound_0123456789876543210 = Apply (Apply PairSym0 MinBoundSym0) MinBoundSym0
-    type MinBound_0123456789876543210Sym0 :: Pair
-    type family MinBound_0123456789876543210Sym0 :: Pair where
-      MinBound_0123456789876543210Sym0 = MinBound_0123456789876543210
     type MaxBound_0123456789876543210 :: Pair
     type family MaxBound_0123456789876543210 :: Pair where
       MaxBound_0123456789876543210 = Apply (Apply PairSym0 MaxBoundSym0) MaxBoundSym0
-    type MaxBound_0123456789876543210Sym0 :: Pair
-    type family MaxBound_0123456789876543210Sym0 :: Pair where
-      MaxBound_0123456789876543210Sym0 = MaxBound_0123456789876543210
     instance PBounded Pair where
-      type MinBound = MinBound_0123456789876543210Sym0
-      type MaxBound = MaxBound_0123456789876543210Sym0
+      type MinBound = MinBound_0123456789876543210
+      type MaxBound = MaxBound_0123456789876543210
     data SFoo1 :: Foo1 -> Type where SFoo1 :: SFoo1 (Foo1 :: Foo1)
     type instance Sing @Foo1 = SFoo1
     instance SingKind Foo1 where
@@ -196,13 +164,12 @@
       type Demote (Foo3 a) = Foo3 (Demote a)
       fromSing (SFoo3 b) = Foo3 (fromSing b)
       toSing (Foo3 (b :: Demote a))
-        = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SFoo3 c)
+        = (\cases (SomeSing c) -> SomeSing (SFoo3 c))
+            (toSing b :: SomeSing a)
     data SFoo4 :: forall (a :: Type) (b :: Type). Foo4 a b -> Type
       where
-        SFoo41 :: forall (a :: Type) (b :: Type).
-                  SFoo4 (Foo41 :: Foo4 (a :: Type) (b :: Type))
-        SFoo42 :: forall (a :: Type) (b :: Type).
-                  SFoo4 (Foo42 :: Foo4 (a :: Type) (b :: Type))
+        SFoo41 :: forall (a :: Type) (b :: Type). SFoo4 (Foo41 :: Foo4 a b)
+        SFoo42 :: forall (a :: Type) (b :: Type). SFoo4 (Foo42 :: Foo4 a b)
     type instance Sing @(Foo4 a b) = SFoo4
     instance (SingKind a, SingKind b) => SingKind (Foo4 a b) where
       type Demote (Foo4 a b) = Foo4 (Demote a) (Demote b)
@@ -217,41 +184,29 @@
     type instance Sing @Pair = SPair
     instance SingKind Pair where
       type Demote Pair = Pair
-      fromSing (SPair b b) = (Pair (fromSing b)) (fromSing b)
+      fromSing (SPair b b) = Pair (fromSing b) (fromSing b)
       toSing (Pair (b :: Demote Bool) (b :: Demote Bool))
-        = case
-              ((,) (toSing b :: SomeSing Bool)) (toSing b :: SomeSing Bool)
-          of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SPair c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SPair c c))
+            (toSing b :: SomeSing Bool) (toSing b :: SomeSing Bool)
     instance SBounded Foo1 where
-      sMinBound :: Sing (MinBoundSym0 :: Foo1)
-      sMaxBound :: Sing (MaxBoundSym0 :: Foo1)
       sMinBound = SFoo1
       sMaxBound = SFoo1
     instance SBounded Foo2 where
-      sMinBound :: Sing (MinBoundSym0 :: Foo2)
-      sMaxBound :: Sing (MaxBoundSym0 :: Foo2)
       sMinBound = SA
       sMaxBound = SE
     instance SBounded a => SBounded (Foo3 a) where
-      sMinBound :: Sing (MinBoundSym0 :: Foo3 a)
-      sMaxBound :: Sing (MaxBoundSym0 :: Foo3 a)
-      sMinBound = (applySing ((singFun1 @Foo3Sym0) SFoo3)) sMinBound
-      sMaxBound = (applySing ((singFun1 @Foo3Sym0) SFoo3)) sMaxBound
+      sMinBound = applySing (singFun1 @Foo3Sym0 SFoo3) sMinBound
+      sMaxBound = applySing (singFun1 @Foo3Sym0 SFoo3) sMaxBound
     instance SBounded (Foo4 a b) where
-      sMinBound :: Sing (MinBoundSym0 :: Foo4 a b)
-      sMaxBound :: Sing (MaxBoundSym0 :: Foo4 a b)
       sMinBound = SFoo41
       sMaxBound = SFoo42
     instance SBounded Bool => SBounded Pair where
-      sMinBound :: Sing (MinBoundSym0 :: Pair)
-      sMaxBound :: Sing (MaxBoundSym0 :: Pair)
       sMinBound
-        = (applySing ((applySing ((singFun2 @PairSym0) SPair)) sMinBound))
-            sMinBound
+        = applySing
+            (applySing (singFun2 @PairSym0 SPair) sMinBound) sMinBound
       sMaxBound
-        = (applySing ((applySing ((singFun2 @PairSym0) SPair)) sMaxBound))
-            sMaxBound
+        = applySing
+            (applySing (singFun2 @PairSym0 SPair) sMaxBound) sMaxBound
     instance SingI Foo1 where
       sing = SFoo1
     instance SingI A where
@@ -269,23 +224,23 @@
     instance SingI1 Foo3 where
       liftSing = SFoo3
     instance SingI (Foo3Sym0 :: (~>) a (Foo3 a)) where
-      sing = (singFun1 @Foo3Sym0) SFoo3
+      sing = singFun1 @Foo3Sym0 SFoo3
     instance SingI Foo41 where
       sing = SFoo41
     instance SingI Foo42 where
       sing = SFoo42
     instance (SingI n, SingI n) =>
              SingI (Pair (n :: Bool) (n :: Bool)) where
-      sing = (SPair sing) sing
+      sing = SPair sing sing
     instance SingI n => SingI1 (Pair (n :: Bool)) where
       liftSing = SPair sing
     instance SingI2 Pair where
       liftSing2 = SPair
     instance SingI (PairSym0 :: (~>) Bool ((~>) Bool Pair)) where
-      sing = (singFun2 @PairSym0) SPair
+      sing = singFun2 @PairSym0 SPair
     instance SingI d =>
              SingI (PairSym1 (d :: Bool) :: (~>) Bool Pair) where
-      sing = (singFun1 @(PairSym1 (d :: Bool))) (SPair (sing @d))
+      sing = singFun1 @(PairSym1 (d :: Bool)) (SPair (sing @d))
     instance SingI1 (PairSym1 :: Bool -> (~>) Bool Pair) where
       liftSing (s :: Sing (d :: Bool))
-        = (singFun1 @(PairSym1 (d :: Bool))) (SPair s)
+        = singFun1 @(PairSym1 (d :: Bool)) (SPair s)
diff --git a/tests/compile-and-dump/Singletons/BoxUnBox.golden b/tests/compile-and-dump/Singletons/BoxUnBox.golden
--- a/tests/compile-and-dump/Singletons/BoxUnBox.golden
+++ b/tests/compile-and-dump/Singletons/BoxUnBox.golden
@@ -13,31 +13,31 @@
       where
         FBoxSym0KindInference :: SameKind (Apply FBoxSym0 arg) (FBoxSym1 arg) =>
                                  FBoxSym0 a0123456789876543210
-    type instance Apply FBoxSym0 a0123456789876543210 = FBox a0123456789876543210
+    type instance Apply @a @(Box a) FBoxSym0 a0123456789876543210 = FBox a0123456789876543210
     instance SuppressUnusedWarnings FBoxSym0 where
-      suppressUnusedWarnings = snd (((,) FBoxSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FBoxSym0KindInference ())
     type FBoxSym1 :: forall a. a -> Box a
-    type family FBoxSym1 (a0123456789876543210 :: a) :: Box a where
+    type family FBoxSym1 @a (a0123456789876543210 :: a) :: Box a where
       FBoxSym1 a0123456789876543210 = FBox a0123456789876543210
     type UnBoxSym0 :: (~>) (Box a) a
     data UnBoxSym0 :: (~>) (Box a) a
       where
         UnBoxSym0KindInference :: SameKind (Apply UnBoxSym0 arg) (UnBoxSym1 arg) =>
                                   UnBoxSym0 a0123456789876543210
-    type instance Apply UnBoxSym0 a0123456789876543210 = UnBox a0123456789876543210
+    type instance Apply @(Box a) @a UnBoxSym0 a0123456789876543210 = UnBox a0123456789876543210
     instance SuppressUnusedWarnings UnBoxSym0 where
-      suppressUnusedWarnings = snd (((,) UnBoxSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) UnBoxSym0KindInference ())
     type UnBoxSym1 :: Box a -> a
-    type family UnBoxSym1 (a0123456789876543210 :: Box a) :: a where
+    type family UnBoxSym1 @a (a0123456789876543210 :: Box a) :: a where
       UnBoxSym1 a0123456789876543210 = UnBox a0123456789876543210
     type UnBox :: Box a -> a
-    type family UnBox (a :: Box a) :: a where
+    type family UnBox @a (a :: Box a) :: a where
       UnBox (FBox a) = a
     sUnBox ::
-      forall a (t :: Box a). Sing t -> Sing (Apply UnBoxSym0 t :: a)
+      (forall (t :: Box a). Sing t -> Sing (UnBox t :: a) :: Type)
     sUnBox (SFBox (sA :: Sing a)) = sA
     instance SingI (UnBoxSym0 :: (~>) (Box a) a) where
-      sing = (singFun1 @UnBoxSym0) sUnBox
+      sing = singFun1 @UnBoxSym0 sUnBox
     data SBox :: forall a. Box a -> Type
       where
         SFBox :: forall a (n :: a). (Sing n) -> SBox (FBox n :: Box a)
@@ -46,10 +46,11 @@
       type Demote (Box a) = Box (Demote a)
       fromSing (SFBox b) = FBox (fromSing b)
       toSing (FBox (b :: Demote a))
-        = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SFBox c)
+        = (\cases (SomeSing c) -> SomeSing (SFBox c))
+            (toSing b :: SomeSing a)
     instance SingI n => SingI (FBox (n :: a)) where
       sing = SFBox sing
     instance SingI1 FBox where
       liftSing = SFBox
     instance SingI (FBoxSym0 :: (~>) a (Box a)) where
-      sing = (singFun1 @FBoxSym0) SFBox
+      sing = singFun1 @FBoxSym0 SFBox
diff --git a/tests/compile-and-dump/Singletons/CaseExpressions.golden b/tests/compile-and-dump/Singletons/CaseExpressions.golden
--- a/tests/compile-and-dump/Singletons/CaseExpressions.golden
+++ b/tests/compile-and-dump/Singletons/CaseExpressions.golden
@@ -37,284 +37,253 @@
                in z
     foo5 :: a -> a
     foo5 x = case x of y -> (\ _ -> x) y
-    type family Case_0123456789876543210 arg_0123456789876543210 y x t where
-      Case_0123456789876543210 arg_0123456789876543210 y x _ = x
-    type family Lambda_0123456789876543210 y x arg_0123456789876543210 where
-      Lambda_0123456789876543210 y x arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 y x arg_0123456789876543210
-    data Lambda_0123456789876543210Sym0 y0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 y0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 y0123456789876543210 = Lambda_0123456789876543210Sym1 y0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 y0123456789876543210 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 y0123456789876543210) arg) (Lambda_0123456789876543210Sym2 y0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 y0123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 y0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 y0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210 arg_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 y0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 y x _ = x
+    data LamCases_0123456789876543210Sym0 y0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) arg) (Lambda_0123456789876543210Sym3 y0123456789876543210 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 y0123456789876543210 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 y0123456789876543210 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 y0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 y0123456789876543210 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 y0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 y0123456789876543210 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 y0123456789876543210 x0123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym3 y0123456789876543210 x0123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 arg_01234567898765432100123456789876543210
-    type family Case_0123456789876543210 x t where
-      Case_0123456789876543210 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 y) x) y
-    data Let0123456789876543210ZSym0 y0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 y0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 y0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 y0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 x y = Apply (LamCases_0123456789876543210Sym0 y x) y
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210ZSym0KindInference :: SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>
-                                                    Let0123456789876543210ZSym0 y0123456789876543210
-    type instance Apply Let0123456789876543210ZSym0 y0123456789876543210 = Let0123456789876543210ZSym1 y0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())
-    data Let0123456789876543210ZSym1 y0123456789876543210 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type family Let0123456789876543210ZSym0 a0123456789876543210 y0123456789876543210 (x0123456789876543210 :: a0123456789876543210) :: a0123456789876543210 where
+      Let0123456789876543210ZSym0 a0123456789876543210 y0123456789876543210 x0123456789876543210 = Let0123456789876543210Z a0123456789876543210 y0123456789876543210 x0123456789876543210
+    type family Let0123456789876543210Z a0123456789876543210 y0123456789876543210 (x0123456789876543210 :: a0123456789876543210) :: a0123456789876543210 where
+      Let0123456789876543210Z a y x = y
+    type family LamCases_0123456789876543210 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 a x y = Let0123456789876543210ZSym0 a y x
+    data LamCases_0123456789876543210Sym0 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210ZSym1KindInference :: SameKind (Apply (Let0123456789876543210ZSym1 y0123456789876543210) arg) (Let0123456789876543210ZSym2 y0123456789876543210 arg) =>
-                                                    Let0123456789876543210ZSym1 y0123456789876543210 x0123456789876543210
-    type instance Apply (Let0123456789876543210ZSym1 y0123456789876543210) x0123456789876543210 = Let0123456789876543210Z y0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210ZSym1 y0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210ZSym1KindInference) ())
-    type family Let0123456789876543210ZSym2 y0123456789876543210 x0123456789876543210 :: a0123456789876543210 where
-      Let0123456789876543210ZSym2 y0123456789876543210 x0123456789876543210 = Let0123456789876543210Z y0123456789876543210 x0123456789876543210
-    type family Let0123456789876543210Z y x :: a where
-      Let0123456789876543210Z y x = y
-    type family Case_0123456789876543210 x t where
-      Case_0123456789876543210 x y = Let0123456789876543210ZSym2 y x
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 a0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 a b '(p, _) = p
+    data LamCases_0123456789876543210Sym0 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 a0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210) where
       suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)
-               ())
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (d0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 d ('Just y) = y
+    data LamCases_0123456789876543210Sym0 (d0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210
-    type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210) b0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 a0123456789876543210 b0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 d0123456789876543210) arg) (LamCases_0123456789876543210Sym1 d0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 d0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 d0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 d0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 d0123456789876543210) where
       suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference)
-               ())
-    type family Let0123456789876543210Scrutinee_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 where
-      Let0123456789876543210Scrutinee_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 a0123456789876543210 b0123456789876543210
-    type family Let0123456789876543210Scrutinee_0123456789876543210 a b where
-      Let0123456789876543210Scrutinee_0123456789876543210 a b = Apply (Apply Tuple2Sym0 a) b
-    type family Case_0123456789876543210 a b t where
-      Case_0123456789876543210 a b '(p, _) = p
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 d0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (d0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 d0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 d0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (d0123456789876543210 :: a0123456789876543210) (x0123456789876543210 :: Maybe a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 d x ('Just y) = y
+      LamCases_0123456789876543210 d x 'Nothing = d
+    data LamCases_0123456789876543210Sym0 (d0123456789876543210 :: a0123456789876543210) (x0123456789876543210 :: Maybe a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 d0123456789876543210
-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 d0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 d0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 d0123456789876543210 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 d0123456789876543210 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 d0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 d0123456789876543210 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 d0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 d0123456789876543210 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)
-               ())
-    type family Let0123456789876543210Scrutinee_0123456789876543210Sym1 d0123456789876543210 where
-      Let0123456789876543210Scrutinee_0123456789876543210Sym1 d0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 d0123456789876543210
-    type family Let0123456789876543210Scrutinee_0123456789876543210 d where
-      Let0123456789876543210Scrutinee_0123456789876543210 d = Apply JustSym0 d
-    type family Case_0123456789876543210 d t where
-      Case_0123456789876543210 d ('Just y) = y
-    type family Case_0123456789876543210 d x t where
-      Case_0123456789876543210 d x ('Just y) = y
-      Case_0123456789876543210 d x 'Nothing = d
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (d0123456789876543210 :: a0123456789876543210) (x0123456789876543210 :: Maybe a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 d0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 d0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
     type Foo5Sym0 :: (~>) a a
     data Foo5Sym0 :: (~>) a a
       where
         Foo5Sym0KindInference :: SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>
                                  Foo5Sym0 a0123456789876543210
-    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210
+    type instance Apply @a @a Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210
     instance SuppressUnusedWarnings Foo5Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo5Sym0KindInference ())
     type Foo5Sym1 :: a -> a
-    type family Foo5Sym1 (a0123456789876543210 :: a) :: a where
+    type family Foo5Sym1 @a (a0123456789876543210 :: a) :: a where
       Foo5Sym1 a0123456789876543210 = Foo5 a0123456789876543210
     type Foo4Sym0 :: forall a. (~>) a a
     data Foo4Sym0 :: (~>) a a
       where
         Foo4Sym0KindInference :: SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>
                                  Foo4Sym0 a0123456789876543210
-    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210
+    type instance Apply @a @a Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210
     instance SuppressUnusedWarnings Foo4Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo4Sym0KindInference ())
     type Foo4Sym1 :: forall a. a -> a
-    type family Foo4Sym1 (a0123456789876543210 :: a) :: a where
+    type family Foo4Sym1 @a (a0123456789876543210 :: a) :: a where
       Foo4Sym1 a0123456789876543210 = Foo4 a0123456789876543210
     type Foo3Sym0 :: (~>) a ((~>) b a)
     data Foo3Sym0 :: (~>) a ((~>) b a)
       where
         Foo3Sym0KindInference :: SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>
                                  Foo3Sym0 a0123456789876543210
-    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b a) Foo3Sym0 a0123456789876543210 = Foo3Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo3Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo3Sym0KindInference ())
     type Foo3Sym1 :: a -> (~>) b a
     data Foo3Sym1 (a0123456789876543210 :: a) :: (~>) b a
       where
         Foo3Sym1KindInference :: SameKind (Apply (Foo3Sym1 a0123456789876543210) arg) (Foo3Sym2 a0123456789876543210 arg) =>
                                  Foo3Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo3Sym1 a0123456789876543210) a0123456789876543210 = Foo3 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @a (Foo3Sym1 a0123456789876543210) a0123456789876543210 = Foo3 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo3Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo3Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo3Sym1KindInference ())
     type Foo3Sym2 :: a -> b -> a
-    type family Foo3Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
+    type family Foo3Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
       Foo3Sym2 a0123456789876543210 a0123456789876543210 = Foo3 a0123456789876543210 a0123456789876543210
     type Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)
     data Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)
       where
         Foo2Sym0KindInference :: SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>
                                  Foo2Sym0 a0123456789876543210
-    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210
+    type instance Apply @a @((~>) (Maybe a) a) Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo2Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo2Sym0KindInference ())
     type Foo2Sym1 :: a -> (~>) (Maybe a) a
     data Foo2Sym1 (a0123456789876543210 :: a) :: (~>) (Maybe a) a
       where
         Foo2Sym1KindInference :: SameKind (Apply (Foo2Sym1 a0123456789876543210) arg) (Foo2Sym2 a0123456789876543210 arg) =>
                                  Foo2Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210
+    type instance Apply @(Maybe a) @a (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo2Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo2Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo2Sym1KindInference ())
     type Foo2Sym2 :: a -> Maybe a -> a
-    type family Foo2Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) :: a where
+    type family Foo2Sym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) :: a where
       Foo2Sym2 a0123456789876543210 a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210
     type Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)
     data Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)
       where
         Foo1Sym0KindInference :: SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>
                                  Foo1Sym0 a0123456789876543210
-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210
+    type instance Apply @a @((~>) (Maybe a) a) Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo1Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo1Sym0KindInference ())
     type Foo1Sym1 :: a -> (~>) (Maybe a) a
     data Foo1Sym1 (a0123456789876543210 :: a) :: (~>) (Maybe a) a
       where
         Foo1Sym1KindInference :: SameKind (Apply (Foo1Sym1 a0123456789876543210) arg) (Foo1Sym2 a0123456789876543210 arg) =>
                                  Foo1Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210
+    type instance Apply @(Maybe a) @a (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo1Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo1Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo1Sym1KindInference ())
     type Foo1Sym2 :: a -> Maybe a -> a
-    type family Foo1Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) :: a where
+    type family Foo1Sym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) :: a where
       Foo1Sym2 a0123456789876543210 a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210
     type Foo5 :: a -> a
-    type family Foo5 (a :: a) :: a where
-      Foo5 x = Case_0123456789876543210 x x
+    type family Foo5 @a (a :: a) :: a where
+      Foo5 x = Apply (LamCases_0123456789876543210Sym0 x) x
     type Foo4 :: forall a. a -> a
-    type family Foo4 (a :: a) :: a where
-      Foo4 x = Case_0123456789876543210 x x
+    type family Foo4 @a (a :: a) :: a where
+      Foo4 @a (x :: a) = Apply (LamCases_0123456789876543210Sym0 a x) x
     type Foo3 :: a -> b -> a
-    type family Foo3 (a :: a) (a :: b) :: a where
-      Foo3 a b = Case_0123456789876543210 a b (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a b)
+    type family Foo3 @a @b (a :: a) (a :: b) :: a where
+      Foo3 a b = Apply (LamCases_0123456789876543210Sym0 a b) (Apply (Apply Tuple2Sym0 a) b)
     type Foo2 :: a -> Maybe a -> a
-    type family Foo2 (a :: a) (a :: Maybe a) :: a where
-      Foo2 d _ = Case_0123456789876543210 d (Let0123456789876543210Scrutinee_0123456789876543210Sym1 d)
+    type family Foo2 @a (a :: a) (a :: Maybe a) :: a where
+      Foo2 d _ = Apply (LamCases_0123456789876543210Sym0 d) (Apply JustSym0 d)
     type Foo1 :: a -> Maybe a -> a
-    type family Foo1 (a :: a) (a :: Maybe a) :: a where
-      Foo1 d x = Case_0123456789876543210 d x x
-    sFoo5 :: forall a (t :: a). Sing t -> Sing (Apply Foo5Sym0 t :: a)
-    sFoo4 :: forall a (t :: a). Sing t -> Sing (Apply Foo4Sym0 t :: a)
+    type family Foo1 @a (a :: a) (a :: Maybe a) :: a where
+      Foo1 d x = Apply (LamCases_0123456789876543210Sym0 d x) x
+    sFoo5 :: (forall (t :: a). Sing t -> Sing (Foo5 t :: a) :: Type)
+    sFoo4 :: forall a (t :: a). Sing t -> Sing (Foo4 t :: a)
     sFoo3 ::
-      forall a b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a)
+      (forall (t :: a) (t :: b).
+       Sing t -> Sing t -> Sing (Foo3 t t :: a) :: Type)
     sFoo2 ::
-      forall a (t :: a) (t :: Maybe a). Sing t
-                                        -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)
+      (forall (t :: a) (t :: Maybe a).
+       Sing t -> Sing t -> Sing (Foo2 t t :: a) :: Type)
     sFoo1 ::
-      forall a (t :: a) (t :: Maybe a). Sing t
-                                        -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)
+      (forall (t :: a) (t :: Maybe a).
+       Sing t -> Sing t -> Sing (Foo1 t t :: a) :: Type)
     sFoo5 (sX :: Sing x)
-      = (id @(Sing (Case_0123456789876543210 x x :: a)))
-          (case sX of
-             (sY :: Sing y)
-               -> (applySing
-                     ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 y) x))
-                        (\ sArg_0123456789876543210
-                           -> case sArg_0123456789876543210 of
-                                (_ :: Sing arg_0123456789876543210)
-                                  -> (id
-                                        @(Sing (Case_0123456789876543210 arg_0123456789876543210 y x arg_0123456789876543210)))
-                                       (case sArg_0123456789876543210 of _ -> sX))))
-                    sY)
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 x)
+             (\cases
+                (sY :: Sing y)
+                  -> applySing
+                       (singFun1 @(LamCases_0123456789876543210Sym0 y x) (\cases _ -> sX))
+                       sY))
+          sX
     sFoo4 (sX :: Sing x)
-      = (id @(Sing (Case_0123456789876543210 x x :: a)))
-          (case sX of
-             (sY :: Sing y)
-               -> let
-                    sZ :: Sing (Let0123456789876543210ZSym2 y x :: a)
-                    sZ = sY
-                  in sZ)
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 a x)
+             (\cases
+                (sY :: Sing y)
+                  -> let
+                       sZ :: (Sing (Let0123456789876543210Z a y x :: a) :: Type)
+                       sZ = sY
+                     in sZ))
+          sX
     sFoo3 (sA :: Sing a) (sB :: Sing b)
-      = let
-          sScrutinee_0123456789876543210 ::
-            Sing @_ (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a b)
-          sScrutinee_0123456789876543210
-            = (applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sA)) sB
-        in
-          (id
-             @(Sing (Case_0123456789876543210 a b (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a b) :: a)))
-            (case sScrutinee_0123456789876543210 of
-               STuple2 (sP :: Sing p) _ -> sP)
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 a b)
+             (\cases (STuple2 (sP :: Sing p) _) -> sP))
+          (applySing (applySing (singFun2 @Tuple2Sym0 STuple2) sA) sB)
     sFoo2 (sD :: Sing d) _
-      = let
-          sScrutinee_0123456789876543210 ::
-            Sing @_ (Let0123456789876543210Scrutinee_0123456789876543210Sym1 d)
-          sScrutinee_0123456789876543210
-            = (applySing ((singFun1 @JustSym0) SJust)) sD
-        in
-          (id
-             @(Sing (Case_0123456789876543210 d (Let0123456789876543210Scrutinee_0123456789876543210Sym1 d) :: a)))
-            (case sScrutinee_0123456789876543210 of SJust (sY :: Sing y) -> sY)
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 d)
+             (\cases (SJust (sY :: Sing y)) -> sY))
+          (applySing (singFun1 @JustSym0 SJust) sD)
     sFoo1 (sD :: Sing d) (sX :: Sing x)
-      = (id @(Sing (Case_0123456789876543210 d x x :: a)))
-          (case sX of
-             SJust (sY :: Sing y) -> sY
-             SNothing -> sD)
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 d x)
+             (\cases
+                (SJust (sY :: Sing y)) -> sY
+                SNothing -> sD))
+          sX
     instance SingI (Foo5Sym0 :: (~>) a a) where
-      sing = (singFun1 @Foo5Sym0) sFoo5
+      sing = singFun1 @Foo5Sym0 sFoo5
     instance SingI (Foo4Sym0 :: (~>) a a) where
-      sing = (singFun1 @Foo4Sym0) sFoo4
+      sing = singFun1 @Foo4Sym0 sFoo4
     instance SingI (Foo3Sym0 :: (~>) a ((~>) b a)) where
-      sing = (singFun2 @Foo3Sym0) sFoo3
+      sing = singFun2 @Foo3Sym0 sFoo3
     instance SingI d => SingI (Foo3Sym1 (d :: a) :: (~>) b a) where
-      sing = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 (sing @d))
+      sing = singFun1 @(Foo3Sym1 (d :: a)) (sFoo3 (sing @d))
     instance SingI1 (Foo3Sym1 :: a -> (~>) b a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 s)
+        = singFun1 @(Foo3Sym1 (d :: a)) (sFoo3 s)
     instance SingI (Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)) where
-      sing = (singFun2 @Foo2Sym0) sFoo2
+      sing = singFun2 @Foo2Sym0 sFoo2
     instance SingI d =>
              SingI (Foo2Sym1 (d :: a) :: (~>) (Maybe a) a) where
-      sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d))
+      sing = singFun1 @(Foo2Sym1 (d :: a)) (sFoo2 (sing @d))
     instance SingI1 (Foo2Sym1 :: a -> (~>) (Maybe a) a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 s)
+        = singFun1 @(Foo2Sym1 (d :: a)) (sFoo2 s)
     instance SingI (Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)) where
-      sing = (singFun2 @Foo1Sym0) sFoo1
+      sing = singFun2 @Foo1Sym0 sFoo1
     instance SingI d =>
              SingI (Foo1Sym1 (d :: a) :: (~>) (Maybe a) a) where
-      sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d))
+      sing = singFun1 @(Foo1Sym1 (d :: a)) (sFoo1 (sing @d))
     instance SingI1 (Foo1Sym1 :: a -> (~>) (Maybe a) a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 s)
+        = singFun1 @(Foo1Sym1 (d :: a)) (sFoo1 s)
diff --git a/tests/compile-and-dump/Singletons/Classes.golden b/tests/compile-and-dump/Singletons/Classes.golden
--- a/tests/compile-and-dump/Singletons/Classes.golden
+++ b/tests/compile-and-dump/Singletons/Classes.golden
@@ -16,20 +16,20 @@
           data Foo = A | B
           data Foo2 = F | G
           
+          instance Eq Foo2 where
+            F == F = True
+            G == G = True
+            F == G = False
+            G == F = False
+          instance MyOrd Foo where
+            mycompare = fooCompare
           instance MyOrd () where
             mycompare _ = const EQ
           instance MyOrd Nat where
             Zero `mycompare` Zero = EQ
             Zero `mycompare` (Succ _) = LT
             (Succ _) `mycompare` Zero = GT
-            (Succ n) `mycompare` (Succ m) = m `mycompare` n
-          instance MyOrd Foo where
-            mycompare = fooCompare
-          instance Eq Foo2 where
-            F == F = True
-            G == G = True
-            F == G = False
-            G == F = False |]
+            (Succ n) `mycompare` (Succ m) = m `mycompare` n |]
   ======>
     const :: a -> b -> a
     const x _ = x
@@ -76,17 +76,17 @@
       where
         FooCompareSym0KindInference :: SameKind (Apply FooCompareSym0 arg) (FooCompareSym1 arg) =>
                                        FooCompareSym0 a0123456789876543210
-    type instance Apply FooCompareSym0 a0123456789876543210 = FooCompareSym1 a0123456789876543210
+    type instance Apply @Foo @((~>) Foo Ordering) FooCompareSym0 a0123456789876543210 = FooCompareSym1 a0123456789876543210
     instance SuppressUnusedWarnings FooCompareSym0 where
-      suppressUnusedWarnings = snd (((,) FooCompareSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooCompareSym0KindInference ())
     type FooCompareSym1 :: Foo -> (~>) Foo Ordering
     data FooCompareSym1 (a0123456789876543210 :: Foo) :: (~>) Foo Ordering
       where
         FooCompareSym1KindInference :: SameKind (Apply (FooCompareSym1 a0123456789876543210) arg) (FooCompareSym2 a0123456789876543210 arg) =>
                                        FooCompareSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FooCompareSym1 a0123456789876543210) a0123456789876543210 = FooCompare a0123456789876543210 a0123456789876543210
+    type instance Apply @Foo @Ordering (FooCompareSym1 a0123456789876543210) a0123456789876543210 = FooCompare a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (FooCompareSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FooCompareSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooCompareSym1KindInference ())
     type FooCompareSym2 :: Foo -> Foo -> Ordering
     type family FooCompareSym2 (a0123456789876543210 :: Foo) (a0123456789876543210 :: Foo) :: Ordering where
       FooCompareSym2 a0123456789876543210 a0123456789876543210 = FooCompare a0123456789876543210 a0123456789876543210
@@ -95,19 +95,19 @@
       where
         ConstSym0KindInference :: SameKind (Apply ConstSym0 arg) (ConstSym1 arg) =>
                                   ConstSym0 a0123456789876543210
-    type instance Apply ConstSym0 a0123456789876543210 = ConstSym1 a0123456789876543210
+    type instance Apply @a @((~>) b a) ConstSym0 a0123456789876543210 = ConstSym1 a0123456789876543210
     instance SuppressUnusedWarnings ConstSym0 where
-      suppressUnusedWarnings = snd (((,) ConstSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) ConstSym0KindInference ())
     type ConstSym1 :: a -> (~>) b a
     data ConstSym1 (a0123456789876543210 :: a) :: (~>) b a
       where
         ConstSym1KindInference :: SameKind (Apply (ConstSym1 a0123456789876543210) arg) (ConstSym2 a0123456789876543210 arg) =>
                                   ConstSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ConstSym1 a0123456789876543210) a0123456789876543210 = Const a0123456789876543210 a0123456789876543210
+    type instance Apply @b @a (ConstSym1 a0123456789876543210) a0123456789876543210 = Const a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (ConstSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ConstSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) ConstSym1KindInference ())
     type ConstSym2 :: a -> b -> a
-    type family ConstSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
+    type family ConstSym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
       ConstSym2 a0123456789876543210 a0123456789876543210 = Const a0123456789876543210 a0123456789876543210
     type FooCompare :: Foo -> Foo -> Ordering
     type family FooCompare (a :: Foo) (a :: Foo) :: Ordering where
@@ -116,214 +116,109 @@
       FooCompare B B = GTSym0
       FooCompare B A = EQSym0
     type Const :: a -> b -> a
-    type family Const (a :: a) (a :: b) :: a where
+    type family Const @a @b (a :: a) (a :: b) :: a where
       Const x _ = x
     type MycompareSym0 :: forall a. (~>) a ((~>) a Ordering)
     data MycompareSym0 :: (~>) a ((~>) a Ordering)
       where
         MycompareSym0KindInference :: SameKind (Apply MycompareSym0 arg) (MycompareSym1 arg) =>
                                       MycompareSym0 a0123456789876543210
-    type instance Apply MycompareSym0 a0123456789876543210 = MycompareSym1 a0123456789876543210
+    type instance Apply @a @((~>) a Ordering) MycompareSym0 a0123456789876543210 = MycompareSym1 a0123456789876543210
     instance SuppressUnusedWarnings MycompareSym0 where
-      suppressUnusedWarnings = snd (((,) MycompareSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MycompareSym0KindInference ())
     type MycompareSym1 :: forall a. a -> (~>) a Ordering
     data MycompareSym1 (a0123456789876543210 :: a) :: (~>) a Ordering
       where
         MycompareSym1KindInference :: SameKind (Apply (MycompareSym1 a0123456789876543210) arg) (MycompareSym2 a0123456789876543210 arg) =>
                                       MycompareSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MycompareSym1 a0123456789876543210) a0123456789876543210 = Mycompare a0123456789876543210 a0123456789876543210
+    type instance Apply @a @Ordering (MycompareSym1 a0123456789876543210) a0123456789876543210 = Mycompare a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MycompareSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MycompareSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) MycompareSym1KindInference ())
     type MycompareSym2 :: forall a. a -> a -> Ordering
-    type family MycompareSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ordering where
+    type family MycompareSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ordering where
       MycompareSym2 a0123456789876543210 a0123456789876543210 = Mycompare a0123456789876543210 a0123456789876543210
     type (<=>@#@$) :: forall a. (~>) a ((~>) a Ordering)
     data (<=>@#@$) :: (~>) a ((~>) a Ordering)
       where
         (:<=>@#@$###) :: SameKind (Apply (<=>@#@$) arg) ((<=>@#@$$) arg) =>
                          (<=>@#@$) a0123456789876543210
-    type instance Apply (<=>@#@$) a0123456789876543210 = (<=>@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) a Ordering) (<=>@#@$) a0123456789876543210 = (<=>@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (<=>@#@$) where
-      suppressUnusedWarnings = snd (((,) (:<=>@#@$###)) ())
-    infix 4 <=>@#@$
+      suppressUnusedWarnings = snd ((,) (:<=>@#@$###) ())
+    infix 4 type <=>@#@$
     type (<=>@#@$$) :: forall a. a -> (~>) a Ordering
     data (<=>@#@$$) (a0123456789876543210 :: a) :: (~>) a Ordering
       where
         (:<=>@#@$$###) :: SameKind (Apply ((<=>@#@$$) a0123456789876543210) arg) ((<=>@#@$$$) a0123456789876543210 arg) =>
                           (<=>@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((<=>@#@$$) a0123456789876543210) a0123456789876543210 = (<=>) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @Ordering ((<=>@#@$$) a0123456789876543210) a0123456789876543210 = (<=>) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((<=>@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:<=>@#@$$###)) ())
-    infix 4 <=>@#@$$
+      suppressUnusedWarnings = snd ((,) (:<=>@#@$$###) ())
+    infix 4 type <=>@#@$$
     type (<=>@#@$$$) :: forall a. a -> a -> Ordering
-    type family (<=>@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ordering where
+    type family (<=>@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ordering where
       (<=>@#@$$$) a0123456789876543210 a0123456789876543210 = (<=>) a0123456789876543210 a0123456789876543210
-    infix 4 <=>@#@$$$
-    type TFHelper_0123456789876543210 :: a -> a -> Ordering
-    type family TFHelper_0123456789876543210 (a :: a) (a :: a) :: Ordering where
-      TFHelper_0123456789876543210 a_0123456789876543210 a_0123456789876543210 = Apply (Apply MycompareSym0 a_0123456789876543210) a_0123456789876543210
-    type TFHelper_0123456789876543210Sym0 :: (~>) a ((~>) a Ordering)
-    data TFHelper_0123456789876543210Sym0 :: (~>) a ((~>) a Ordering)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: a -> (~>) a Ordering
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: a) :: (~>) a Ordering
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: a -> a -> Ordering
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ordering where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
+    infix 4 type <=>@#@$$$
+    type TFHelper_0123456789876543210 :: forall a. a -> a -> Ordering
+    type family TFHelper_0123456789876543210 @a (a :: a) (a :: a) :: Ordering where
+      TFHelper_0123456789876543210 @a (a_0123456789876543210 :: a) (a_0123456789876543210 :: a) = Apply (Apply MycompareSym0 a_0123456789876543210) a_0123456789876543210
     class PMyOrd a where
       type family Mycompare (arg :: a) (arg :: a) :: Ordering
       type family (<=>) (arg :: a) (arg :: a) :: Ordering
-      type (<=>) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
+      type (<=>) a a = TFHelper_0123456789876543210 a a
     type Mycompare_0123456789876543210 :: Nat -> Nat -> Ordering
     type family Mycompare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where
       Mycompare_0123456789876543210 'Zero 'Zero = EQSym0
       Mycompare_0123456789876543210 'Zero ('Succ _) = LTSym0
       Mycompare_0123456789876543210 ('Succ _) 'Zero = GTSym0
       Mycompare_0123456789876543210 ('Succ n) ('Succ m) = Apply (Apply MycompareSym0 m) n
-    type Mycompare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)
-    data Mycompare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)
-      where
-        Mycompare_0123456789876543210Sym0KindInference :: SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>
-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Mycompare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())
-    type Mycompare_0123456789876543210Sym1 :: Nat -> (~>) Nat Ordering
-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering
-      where
-        Mycompare_0123456789876543210Sym1KindInference :: SameKind (Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) arg) (Mycompare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          Mycompare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())
-    type Mycompare_0123456789876543210Sym2 :: Nat -> Nat -> Ordering
-    type family Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Ordering where
-      Mycompare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PMyOrd Nat where
-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a
+      type Mycompare a a = Mycompare_0123456789876543210 a a
     type Mycompare_0123456789876543210 :: () -> () -> Ordering
     type family Mycompare_0123456789876543210 (a :: ()) (a :: ()) :: Ordering where
       Mycompare_0123456789876543210 _ a_0123456789876543210 = Apply (Apply ConstSym0 EQSym0) a_0123456789876543210
-    type Mycompare_0123456789876543210Sym0 :: (~>) () ((~>) () Ordering)
-    data Mycompare_0123456789876543210Sym0 :: (~>) () ((~>) () Ordering)
-      where
-        Mycompare_0123456789876543210Sym0KindInference :: SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>
-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Mycompare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())
-    type Mycompare_0123456789876543210Sym1 :: () -> (~>) () Ordering
-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: ()) :: (~>) () Ordering
-      where
-        Mycompare_0123456789876543210Sym1KindInference :: SameKind (Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) arg) (Mycompare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          Mycompare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())
-    type Mycompare_0123456789876543210Sym2 :: () -> () -> Ordering
-    type family Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: ()) (a0123456789876543210 :: ()) :: Ordering where
-      Mycompare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PMyOrd () where
-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a
+      type Mycompare a a = Mycompare_0123456789876543210 a a
     type Mycompare_0123456789876543210 :: Foo -> Foo -> Ordering
     type family Mycompare_0123456789876543210 (a :: Foo) (a :: Foo) :: Ordering where
       Mycompare_0123456789876543210 a_0123456789876543210 a_0123456789876543210 = Apply (Apply FooCompareSym0 a_0123456789876543210) a_0123456789876543210
-    type Mycompare_0123456789876543210Sym0 :: (~>) Foo ((~>) Foo Ordering)
-    data Mycompare_0123456789876543210Sym0 :: (~>) Foo ((~>) Foo Ordering)
-      where
-        Mycompare_0123456789876543210Sym0KindInference :: SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>
-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Mycompare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())
-    type Mycompare_0123456789876543210Sym1 :: Foo -> (~>) Foo Ordering
-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Foo) :: (~>) Foo Ordering
-      where
-        Mycompare_0123456789876543210Sym1KindInference :: SameKind (Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) arg) (Mycompare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          Mycompare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())
-    type Mycompare_0123456789876543210Sym2 :: Foo -> Foo -> Ordering
-    type family Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: Foo) (a0123456789876543210 :: Foo) :: Ordering where
-      Mycompare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PMyOrd Foo where
-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a
+      type Mycompare a a = Mycompare_0123456789876543210 a a
     type TFHelper_0123456789876543210 :: Foo2 -> Foo2 -> Bool
     type family TFHelper_0123456789876543210 (a :: Foo2) (a :: Foo2) :: Bool where
       TFHelper_0123456789876543210 F F = TrueSym0
       TFHelper_0123456789876543210 G G = TrueSym0
       TFHelper_0123456789876543210 F G = FalseSym0
       TFHelper_0123456789876543210 G F = FalseSym0
-    type TFHelper_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Foo2 -> (~>) Foo2 Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Foo2) :: (~>) Foo2 Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Foo2 -> Foo2 -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Foo2) (a0123456789876543210 :: Foo2) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PEq Foo2 where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
+      type (==) a a = TFHelper_0123456789876543210 a a
     sFooCompare ::
-      forall (t :: Foo) (t :: Foo). Sing t
-                                    -> Sing t -> Sing (Apply (Apply FooCompareSym0 t) t :: Ordering)
+      (forall (t :: Foo) (t :: Foo).
+       Sing t -> Sing t -> Sing (FooCompare t t :: Ordering) :: Type)
     sConst ::
-      forall a b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply ConstSym0 t) t :: a)
+      (forall (t :: a) (t :: b).
+       Sing t -> Sing t -> Sing (Const t t :: a) :: Type)
     sFooCompare SA SA = SEQ
     sFooCompare SA SB = SLT
     sFooCompare SB SB = SGT
     sFooCompare SB SA = SEQ
     sConst (sX :: Sing x) _ = sX
     instance SingI (FooCompareSym0 :: (~>) Foo ((~>) Foo Ordering)) where
-      sing = (singFun2 @FooCompareSym0) sFooCompare
+      sing = singFun2 @FooCompareSym0 sFooCompare
     instance SingI d =>
              SingI (FooCompareSym1 (d :: Foo) :: (~>) Foo Ordering) where
       sing
-        = (singFun1 @(FooCompareSym1 (d :: Foo))) (sFooCompare (sing @d))
+        = singFun1 @(FooCompareSym1 (d :: Foo)) (sFooCompare (sing @d))
     instance SingI1 (FooCompareSym1 :: Foo -> (~>) Foo Ordering) where
       liftSing (s :: Sing (d :: Foo))
-        = (singFun1 @(FooCompareSym1 (d :: Foo))) (sFooCompare s)
+        = singFun1 @(FooCompareSym1 (d :: Foo)) (sFooCompare s)
     instance SingI (ConstSym0 :: (~>) a ((~>) b a)) where
-      sing = (singFun2 @ConstSym0) sConst
+      sing = singFun2 @ConstSym0 sConst
     instance SingI d => SingI (ConstSym1 (d :: a) :: (~>) b a) where
-      sing = (singFun1 @(ConstSym1 (d :: a))) (sConst (sing @d))
+      sing = singFun1 @(ConstSym1 (d :: a)) (sConst (sing @d))
     instance SingI1 (ConstSym1 :: a -> (~>) b a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(ConstSym1 (d :: a))) (sConst s)
+        = singFun1 @(ConstSym1 (d :: a)) (sConst s)
     data SFoo :: Foo -> Type
       where
         SA :: SFoo (A :: Foo)
@@ -348,61 +243,42 @@
       toSing G = SomeSing SG
     class SMyOrd a where
       sMycompare ::
-        forall (t :: a) (t :: a). Sing t
-                                  -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)
+        (forall (t :: a) (t :: a).
+         Sing t -> Sing t -> Sing (Mycompare t t :: Ordering) :: Type)
       (%<=>) ::
-        forall (t :: a) (t :: a). Sing t
-                                  -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering)
-      infix 4 %<=>
+        (forall (t :: a) (t :: a).
+         Sing t -> Sing t -> Sing ((<=>) t t :: Ordering) :: Type)
+      infix 4 data %<=>
       default (%<=>) ::
-                forall (t :: a)
-                       (t :: a). ((Apply (Apply (<=>@#@$) t) t :: Ordering)
-                                  ~ Apply (Apply TFHelper_0123456789876543210Sym0 t) t) =>
-                                 Sing t -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering)
+                (forall (t :: a) (t :: a).
+                 (((<=>) t t :: Ordering) ~ TFHelper_0123456789876543210 t t) =>
+                 Sing t -> Sing t -> Sing ((<=>) t t :: Ordering) :: Type)
       (%<=>)
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @MycompareSym0) sMycompare))
-                sA_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @MycompareSym0 sMycompare) sA_0123456789876543210)
             sA_0123456789876543210
     instance SMyOrd Nat where
-      sMycompare ::
-        forall (t :: Nat) (t :: Nat). Sing t
-                                      -> Sing t
-                                         -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)
       sMycompare SZero SZero = SEQ
       sMycompare SZero (SSucc _) = SLT
       sMycompare (SSucc _) SZero = SGT
       sMycompare (SSucc (sN :: Sing n)) (SSucc (sM :: Sing m))
-        = (applySing
-             ((applySing ((singFun2 @MycompareSym0) sMycompare)) sM))
-            sN
+        = applySing (applySing (singFun2 @MycompareSym0 sMycompare) sM) sN
     instance SMyOrd () where
-      sMycompare ::
-        forall (t :: ()) (t :: ()). Sing t
-                                    -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)
       sMycompare _ (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing ((applySing ((singFun2 @ConstSym0) sConst)) SEQ))
-            sA_0123456789876543210
+        = applySing
+            (applySing (singFun2 @ConstSym0 sConst) SEQ) sA_0123456789876543210
     instance SMyOrd Foo where
-      sMycompare ::
-        forall (t :: Foo) (t :: Foo). Sing t
-                                      -> Sing t
-                                         -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)
       sMycompare
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @FooCompareSym0) sFooCompare))
-                sA_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @FooCompareSym0 sFooCompare) sA_0123456789876543210)
             sA_0123456789876543210
     instance SEq Foo2 where
-      (%==) ::
-        forall (t1 :: Foo2) (t2 :: Foo2). Sing t1
-                                          -> Sing t2
-                                             -> Sing (Apply (Apply ((==@#@$) :: TyFun Foo2 ((~>) Foo2 Bool)
-                                                                                -> Type) t1) t2)
       (%==) SF SF = STrue
       (%==) SG SG = STrue
       (%==) SF SG = SFalse
@@ -417,24 +293,24 @@
       sing = SG
     instance SMyOrd a =>
              SingI (MycompareSym0 :: (~>) a ((~>) a Ordering)) where
-      sing = (singFun2 @MycompareSym0) sMycompare
+      sing = singFun2 @MycompareSym0 sMycompare
     instance (SMyOrd a, SingI d) =>
              SingI (MycompareSym1 (d :: a) :: (~>) a Ordering) where
-      sing = (singFun1 @(MycompareSym1 (d :: a))) (sMycompare (sing @d))
+      sing = singFun1 @(MycompareSym1 (d :: a)) (sMycompare (sing @d))
     instance SMyOrd a =>
              SingI1 (MycompareSym1 :: a -> (~>) a Ordering) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(MycompareSym1 (d :: a))) (sMycompare s)
+        = singFun1 @(MycompareSym1 (d :: a)) (sMycompare s)
     instance SMyOrd a =>
              SingI ((<=>@#@$) :: (~>) a ((~>) a Ordering)) where
-      sing = (singFun2 @(<=>@#@$)) (%<=>)
+      sing = singFun2 @(<=>@#@$) (%<=>)
     instance (SMyOrd a, SingI d) =>
              SingI ((<=>@#@$$) (d :: a) :: (~>) a Ordering) where
-      sing = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) (sing @d))
+      sing = singFun1 @((<=>@#@$$) (d :: a)) ((%<=>) (sing @d))
     instance SMyOrd a =>
              SingI1 ((<=>@#@$$) :: a -> (~>) a Ordering) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) s)
+        = singFun1 @((<=>@#@$$) (d :: a)) ((%<=>) s)
 Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations
     promote
       [d| instance Ord Foo2 where
@@ -459,58 +335,15 @@
       Mycompare_0123456789876543210 'F 'F = EQSym0
       Mycompare_0123456789876543210 'F _ = LTSym0
       Mycompare_0123456789876543210 _ _ = GTSym0
-    type Mycompare_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Ordering)
-    data Mycompare_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Ordering)
-      where
-        Mycompare_0123456789876543210Sym0KindInference :: SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>
-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Mycompare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())
-    type Mycompare_0123456789876543210Sym1 :: Foo2
-                                              -> (~>) Foo2 Ordering
-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Foo2) :: (~>) Foo2 Ordering
-      where
-        Mycompare_0123456789876543210Sym1KindInference :: SameKind (Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) arg) (Mycompare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          Mycompare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())
-    type Mycompare_0123456789876543210Sym2 :: Foo2 -> Foo2 -> Ordering
-    type family Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: Foo2) (a0123456789876543210 :: Foo2) :: Ordering where
-      Mycompare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PMyOrd Foo2 where
-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a
+      type Mycompare a a = Mycompare_0123456789876543210 a a
     type Compare_0123456789876543210 :: Foo2 -> Foo2 -> Ordering
     type family Compare_0123456789876543210 (a :: Foo2) (a :: Foo2) :: Ordering where
       Compare_0123456789876543210 'F 'F = EQSym0
       Compare_0123456789876543210 'F _ = LTSym0
       Compare_0123456789876543210 _ _ = GTSym0
-    type Compare_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: Foo2 -> (~>) Foo2 Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Foo2) :: (~>) Foo2 Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: Foo2 -> Foo2 -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: Foo2) (a0123456789876543210 :: Foo2) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance POrd Foo2 where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
+      type Compare a a = Compare_0123456789876543210 a a
 Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations
     singletons
       [d| data Nat' = Zero' | Succ' Nat'
@@ -535,9 +368,9 @@
       where
         Succ'Sym0KindInference :: SameKind (Apply Succ'Sym0 arg) (Succ'Sym1 arg) =>
                                   Succ'Sym0 a0123456789876543210
-    type instance Apply Succ'Sym0 a0123456789876543210 = Succ' a0123456789876543210
+    type instance Apply @Nat' @Nat' Succ'Sym0 a0123456789876543210 = Succ' a0123456789876543210
     instance SuppressUnusedWarnings Succ'Sym0 where
-      suppressUnusedWarnings = snd (((,) Succ'Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Succ'Sym0KindInference ())
     type Succ'Sym1 :: Nat' -> Nat'
     type family Succ'Sym1 (a0123456789876543210 :: Nat') :: Nat' where
       Succ'Sym1 a0123456789876543210 = Succ' a0123456789876543210
@@ -547,30 +380,8 @@
       Mycompare_0123456789876543210 Zero' (Succ' _) = LTSym0
       Mycompare_0123456789876543210 (Succ' _) Zero' = GTSym0
       Mycompare_0123456789876543210 (Succ' n) (Succ' m) = Apply (Apply MycompareSym0 m) n
-    type Mycompare_0123456789876543210Sym0 :: (~>) Nat' ((~>) Nat' Ordering)
-    data Mycompare_0123456789876543210Sym0 :: (~>) Nat' ((~>) Nat' Ordering)
-      where
-        Mycompare_0123456789876543210Sym0KindInference :: SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>
-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Mycompare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())
-    type Mycompare_0123456789876543210Sym1 :: Nat'
-                                              -> (~>) Nat' Ordering
-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Nat') :: (~>) Nat' Ordering
-      where
-        Mycompare_0123456789876543210Sym1KindInference :: SameKind (Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) arg) (Mycompare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          Mycompare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())
-    type Mycompare_0123456789876543210Sym2 :: Nat' -> Nat' -> Ordering
-    type family Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: Nat') (a0123456789876543210 :: Nat') :: Ordering where
-      Mycompare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PMyOrd Nat' where
-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a
+      type Mycompare a a = Mycompare_0123456789876543210 a a
     data SNat' :: Nat' -> Type
       where
         SZero' :: SNat' (Zero' :: Nat')
@@ -582,21 +393,14 @@
       fromSing (SSucc' b) = Succ' (fromSing b)
       toSing Zero' = SomeSing SZero'
       toSing (Succ' (b :: Demote Nat'))
-        = case toSing b :: SomeSing Nat' of
-            SomeSing c -> SomeSing (SSucc' c)
+        = (\cases (SomeSing c) -> SomeSing (SSucc' c))
+            (toSing b :: SomeSing Nat')
     instance SMyOrd Nat' where
-      sMycompare ::
-        forall (t :: Nat') (t :: Nat'). Sing t
-                                        -> Sing t
-                                           -> Sing (Apply (Apply (MycompareSym0 :: TyFun Nat' ((~>) Nat' Ordering)
-                                                                                   -> Type) t) t)
       sMycompare SZero' SZero' = SEQ
       sMycompare SZero' (SSucc' _) = SLT
       sMycompare (SSucc' _) SZero' = SGT
       sMycompare (SSucc' (sN :: Sing n)) (SSucc' (sM :: Sing m))
-        = (applySing
-             ((applySing ((singFun2 @MycompareSym0) sMycompare)) sM))
-            sN
+        = applySing (applySing (singFun2 @MycompareSym0 sMycompare) sM) sN
     instance SingI Zero' where
       sing = SZero'
     instance SingI n => SingI (Succ' (n :: Nat')) where
@@ -604,4 +408,4 @@
     instance SingI1 Succ' where
       liftSing = SSucc'
     instance SingI (Succ'Sym0 :: (~>) Nat' Nat') where
-      sing = (singFun1 @Succ'Sym0) SSucc'
+      sing = singFun1 @Succ'Sym0 SSucc'
diff --git a/tests/compile-and-dump/Singletons/Classes2.golden b/tests/compile-and-dump/Singletons/Classes2.golden
--- a/tests/compile-and-dump/Singletons/Classes2.golden
+++ b/tests/compile-and-dump/Singletons/Classes2.golden
@@ -22,9 +22,9 @@
       where
         SuccFooSym0KindInference :: SameKind (Apply SuccFooSym0 arg) (SuccFooSym1 arg) =>
                                     SuccFooSym0 a0123456789876543210
-    type instance Apply SuccFooSym0 a0123456789876543210 = SuccFoo a0123456789876543210
+    type instance Apply @NatFoo @NatFoo SuccFooSym0 a0123456789876543210 = SuccFoo a0123456789876543210
     instance SuppressUnusedWarnings SuccFooSym0 where
-      suppressUnusedWarnings = snd (((,) SuccFooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SuccFooSym0KindInference ())
     type SuccFooSym1 :: NatFoo -> NatFoo
     type family SuccFooSym1 (a0123456789876543210 :: NatFoo) :: NatFoo where
       SuccFooSym1 a0123456789876543210 = SuccFoo a0123456789876543210
@@ -34,31 +34,8 @@
       Mycompare_0123456789876543210 ZeroFoo (SuccFoo _) = LTSym0
       Mycompare_0123456789876543210 (SuccFoo _) ZeroFoo = GTSym0
       Mycompare_0123456789876543210 (SuccFoo n) (SuccFoo m) = Apply (Apply MycompareSym0 m) n
-    type Mycompare_0123456789876543210Sym0 :: (~>) NatFoo ((~>) NatFoo Ordering)
-    data Mycompare_0123456789876543210Sym0 :: (~>) NatFoo ((~>) NatFoo Ordering)
-      where
-        Mycompare_0123456789876543210Sym0KindInference :: SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>
-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Mycompare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())
-    type Mycompare_0123456789876543210Sym1 :: NatFoo
-                                              -> (~>) NatFoo Ordering
-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: NatFoo) :: (~>) NatFoo Ordering
-      where
-        Mycompare_0123456789876543210Sym1KindInference :: SameKind (Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) arg) (Mycompare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          Mycompare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Mycompare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())
-    type Mycompare_0123456789876543210Sym2 :: NatFoo
-                                              -> NatFoo -> Ordering
-    type family Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: NatFoo) (a0123456789876543210 :: NatFoo) :: Ordering where
-      Mycompare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PMyOrd NatFoo where
-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a
+      type Mycompare a a = Mycompare_0123456789876543210 a a
     data SNatFoo :: NatFoo -> Type
       where
         SZeroFoo :: SNatFoo (ZeroFoo :: NatFoo)
@@ -71,21 +48,14 @@
       fromSing (SSuccFoo b) = SuccFoo (fromSing b)
       toSing ZeroFoo = SomeSing SZeroFoo
       toSing (SuccFoo (b :: Demote NatFoo))
-        = case toSing b :: SomeSing NatFoo of
-            SomeSing c -> SomeSing (SSuccFoo c)
+        = (\cases (SomeSing c) -> SomeSing (SSuccFoo c))
+            (toSing b :: SomeSing NatFoo)
     instance SMyOrd NatFoo where
-      sMycompare ::
-        forall (t1 :: NatFoo) (t2 :: NatFoo). Sing t1
-                                              -> Sing t2
-                                                 -> Sing (Apply (Apply (MycompareSym0 :: TyFun NatFoo ((~>) NatFoo Ordering)
-                                                                                         -> Type) t1) t2)
       sMycompare SZeroFoo SZeroFoo = SEQ
       sMycompare SZeroFoo (SSuccFoo _) = SLT
       sMycompare (SSuccFoo _) SZeroFoo = SGT
       sMycompare (SSuccFoo (sN :: Sing n)) (SSuccFoo (sM :: Sing m))
-        = (applySing
-             ((applySing ((singFun2 @MycompareSym0) sMycompare)) sM))
-            sN
+        = applySing (applySing (singFun2 @MycompareSym0 sMycompare) sM) sN
     instance SingI ZeroFoo where
       sing = SZeroFoo
     instance SingI n => SingI (SuccFoo (n :: NatFoo)) where
@@ -93,4 +63,4 @@
     instance SingI1 SuccFoo where
       liftSing = SSuccFoo
     instance SingI (SuccFooSym0 :: (~>) NatFoo NatFoo) where
-      sing = (singFun1 @SuccFooSym0) SSuccFoo
+      sing = singFun1 @SuccFooSym0 SSuccFoo
diff --git a/tests/compile-and-dump/Singletons/Contains.golden b/tests/compile-and-dump/Singletons/Contains.golden
--- a/tests/compile-and-dump/Singletons/Contains.golden
+++ b/tests/compile-and-dump/Singletons/Contains.golden
@@ -6,48 +6,46 @@
   ======>
     contains :: Eq a => a -> [a] -> Bool
     contains _ [] = False
-    contains elt (h : t) = ((elt == h) || (contains elt) t)
+    contains elt (h : t) = ((elt == h) || contains elt t)
     type ContainsSym0 :: (~>) a ((~>) [a] Bool)
     data ContainsSym0 :: (~>) a ((~>) [a] Bool)
       where
         ContainsSym0KindInference :: SameKind (Apply ContainsSym0 arg) (ContainsSym1 arg) =>
                                      ContainsSym0 a0123456789876543210
-    type instance Apply ContainsSym0 a0123456789876543210 = ContainsSym1 a0123456789876543210
+    type instance Apply @a @((~>) [a] Bool) ContainsSym0 a0123456789876543210 = ContainsSym1 a0123456789876543210
     instance SuppressUnusedWarnings ContainsSym0 where
-      suppressUnusedWarnings = snd (((,) ContainsSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) ContainsSym0KindInference ())
     type ContainsSym1 :: a -> (~>) [a] Bool
     data ContainsSym1 (a0123456789876543210 :: a) :: (~>) [a] Bool
       where
         ContainsSym1KindInference :: SameKind (Apply (ContainsSym1 a0123456789876543210) arg) (ContainsSym2 a0123456789876543210 arg) =>
                                      ContainsSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ContainsSym1 a0123456789876543210) a0123456789876543210 = Contains a0123456789876543210 a0123456789876543210
+    type instance Apply @[a] @Bool (ContainsSym1 a0123456789876543210) a0123456789876543210 = Contains a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (ContainsSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ContainsSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) ContainsSym1KindInference ())
     type ContainsSym2 :: a -> [a] -> Bool
-    type family ContainsSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: [a]) :: Bool where
+    type family ContainsSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: [a]) :: Bool where
       ContainsSym2 a0123456789876543210 a0123456789876543210 = Contains a0123456789876543210 a0123456789876543210
     type Contains :: a -> [a] -> Bool
-    type family Contains (a :: a) (a :: [a]) :: Bool where
+    type family Contains @a (a :: a) (a :: [a]) :: Bool where
       Contains _ '[] = FalseSym0
       Contains elt ('(:) h t) = Apply (Apply (||@#@$) (Apply (Apply (==@#@$) elt) h)) (Apply (Apply ContainsSym0 elt) t)
     sContains ::
-      forall a (t :: a) (t :: [a]). SEq a =>
-                                    Sing t
-                                    -> Sing t -> Sing (Apply (Apply ContainsSym0 t) t :: Bool)
+      (forall (t :: a) (t :: [a]).
+       SEq a => Sing t -> Sing t -> Sing (Contains t t :: Bool) :: Type)
     sContains _ SNil = SFalse
     sContains (sElt :: Sing elt) (SCons (sH :: Sing h) (sT :: Sing t))
-      = (applySing
-           ((applySing ((singFun2 @(||@#@$)) (%||)))
-              ((applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sElt)) sH)))
-          ((applySing
-              ((applySing ((singFun2 @ContainsSym0) sContains)) sElt))
-             sT)
+      = applySing
+          (applySing
+             (singFun2 @(||@#@$) (%||))
+             (applySing (applySing (singFun2 @(==@#@$) (%==)) sElt) sH))
+          (applySing (applySing (singFun2 @ContainsSym0 sContains) sElt) sT)
     instance SEq a =>
              SingI (ContainsSym0 :: (~>) a ((~>) [a] Bool)) where
-      sing = (singFun2 @ContainsSym0) sContains
+      sing = singFun2 @ContainsSym0 sContains
     instance (SEq a, SingI d) =>
              SingI (ContainsSym1 (d :: a) :: (~>) [a] Bool) where
-      sing = (singFun1 @(ContainsSym1 (d :: a))) (sContains (sing @d))
+      sing = singFun1 @(ContainsSym1 (d :: a)) (sContains (sing @d))
     instance SEq a => SingI1 (ContainsSym1 :: a -> (~>) [a] Bool) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(ContainsSym1 (d :: a))) (sContains s)
+        = singFun1 @(ContainsSym1 (d :: a)) (sContains s)
diff --git a/tests/compile-and-dump/Singletons/DataValues.golden b/tests/compile-and-dump/Singletons/DataValues.golden
--- a/tests/compile-and-dump/Singletons/DataValues.golden
+++ b/tests/compile-and-dump/Singletons/DataValues.golden
@@ -12,8 +12,8 @@
     data Pair a b
       = Pair a b
       deriving Show
-    pr = (Pair (Succ Zero)) [Zero]
-    complex = (Pair ((Pair (Just Zero)) Zero)) False
+    pr = Pair (Succ Zero) [Zero]
+    complex = Pair (Pair (Just Zero) Zero) False
     tuple = (False, Just Zero, True)
     aList = [Zero, Succ Zero, Succ (Succ Zero)]
     type PairSym0 :: forall a b. (~>) a ((~>) b (Pair a b))
@@ -21,19 +21,19 @@
       where
         PairSym0KindInference :: SameKind (Apply PairSym0 arg) (PairSym1 arg) =>
                                  PairSym0 a0123456789876543210
-    type instance Apply PairSym0 a0123456789876543210 = PairSym1 a0123456789876543210
+    type instance Apply @a @((~>) b (Pair a b)) PairSym0 a0123456789876543210 = PairSym1 a0123456789876543210
     instance SuppressUnusedWarnings PairSym0 where
-      suppressUnusedWarnings = snd (((,) PairSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) PairSym0KindInference ())
     type PairSym1 :: forall a b. a -> (~>) b (Pair a b)
     data PairSym1 (a0123456789876543210 :: a) :: (~>) b (Pair a b)
       where
         PairSym1KindInference :: SameKind (Apply (PairSym1 a0123456789876543210) arg) (PairSym2 a0123456789876543210 arg) =>
                                  PairSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (PairSym1 a0123456789876543210) a0123456789876543210 = Pair a0123456789876543210 a0123456789876543210
+    type instance Apply @b @(Pair a b) (PairSym1 a0123456789876543210) a0123456789876543210 = Pair a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (PairSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) PairSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) PairSym1KindInference ())
     type PairSym2 :: forall a b. a -> b -> Pair a b
-    type family PairSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Pair a b where
+    type family PairSym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Pair a b where
       PairSym2 a0123456789876543210 a0123456789876543210 = Pair a0123456789876543210 a0123456789876543210
     type family AListSym0 where
       AListSym0 = AList
@@ -51,77 +51,53 @@
       Complex = Apply (Apply PairSym0 (Apply (Apply PairSym0 (Apply JustSym0 ZeroSym0)) ZeroSym0)) FalseSym0
     type family Pr where
       Pr = Apply (Apply PairSym0 (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:@#@$) ZeroSym0) NilSym0)
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> Pair a b -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Pair a b) (a :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210 p_0123456789876543210 (Pair arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Pair ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) (Pair a b) ((~>) Symbol Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (Pair a b) ((~>) Symbol Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> Pair a b -> (~>) Symbol Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Pair a b) :: (~>) Symbol Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> Pair a b -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Pair a b) (a0123456789876543210 :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type ShowsPrec_0123456789876543210 :: forall a
+                                                 b. GHC.Internal.Bignum.Natural.Natural
+                                                    -> Pair a b -> Symbol -> Symbol
+    type family ShowsPrec_0123456789876543210 @a @b (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Pair a b) (a :: Symbol) :: Symbol where
+      ShowsPrec_0123456789876543210 @a @b (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (Pair arg_0123456789876543210 arg_0123456789876543210 :: Pair a b) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Pair ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210
     instance PShow (Pair a b) where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
-    sAList :: Sing @_ AListSym0
-    sTuple :: Sing @_ TupleSym0
-    sComplex :: Sing @_ ComplexSym0
-    sPr :: Sing @_ PrSym0
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
+    sAList :: Sing @_ AList
+    sTuple :: Sing @_ Tuple
+    sComplex :: Sing @_ Complex
+    sPr :: Sing @_ Pr
     sAList
-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))
-          ((applySing
-              ((applySing ((singFun2 @(:@#@$)) SCons))
-                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
-             ((applySing
-                 ((applySing ((singFun2 @(:@#@$)) SCons))
-                    ((applySing ((singFun1 @SuccSym0) SSucc))
-                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))
+      = applySing
+          (applySing (singFun2 @(:@#@$) SCons) SZero)
+          (applySing
+             (applySing
+                (singFun2 @(:@#@$) SCons)
+                (applySing (singFun1 @SuccSym0 SSucc) SZero))
+             (applySing
+                (applySing
+                   (singFun2 @(:@#@$) SCons)
+                   (applySing
+                      (singFun1 @SuccSym0 SSucc)
+                      (applySing (singFun1 @SuccSym0 SSucc) SZero)))
                 SNil))
     sTuple
-      = (applySing
-           ((applySing ((applySing ((singFun3 @Tuple3Sym0) STuple3)) SFalse))
-              ((applySing ((singFun1 @JustSym0) SJust)) SZero)))
+      = applySing
+          (applySing
+             (applySing (singFun3 @Tuple3Sym0 STuple3) SFalse)
+             (applySing (singFun1 @JustSym0 SJust) SZero))
           STrue
     sComplex
-      = (applySing
-           ((applySing ((singFun2 @PairSym0) SPair))
-              ((applySing
-                  ((applySing ((singFun2 @PairSym0) SPair))
-                     ((applySing ((singFun1 @JustSym0) SJust)) SZero)))
-                 SZero)))
+      = applySing
+          (applySing
+             (singFun2 @PairSym0 SPair)
+             (applySing
+                (applySing
+                   (singFun2 @PairSym0 SPair)
+                   (applySing (singFun1 @JustSym0 SJust) SZero))
+                SZero))
           SFalse
     sPr
-      = (applySing
-           ((applySing ((singFun2 @PairSym0) SPair))
-              ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero)) SNil)
+      = applySing
+          (applySing
+             (singFun2 @PairSym0 SPair)
+             (applySing (singFun1 @SuccSym0 SSucc) SZero))
+          (applySing (applySing (singFun2 @(:@#@$) SCons) SZero) SNil)
     data SPair :: forall a b. Pair a b -> Type
       where
         SPair :: forall a b (n :: a) (n :: b).
@@ -129,62 +105,59 @@
     type instance Sing @(Pair a b) = SPair
     instance (SingKind a, SingKind b) => SingKind (Pair a b) where
       type Demote (Pair a b) = Pair (Demote a) (Demote b)
-      fromSing (SPair b b) = (Pair (fromSing b)) (fromSing b)
+      fromSing (SPair b b) = Pair (fromSing b) (fromSing b)
       toSing (Pair (b :: Demote a) (b :: Demote b))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SPair c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SPair c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
     instance (SShow a, SShow b) => SShow (Pair a b) where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: Pair a b)
-               (t3 :: Symbol). Sing t1
-                               -> Sing t2
-                                  -> Sing t3
-                                     -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol))
-                                                                                    -> Type) t1) t2) t3)
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         (SPair (sArg_0123456789876543210 :: Sing arg_0123456789876543210)
                (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "Pair "))))
-                   ((applySing
-                       ((applySing ((singFun3 @(.@#@$)) (%.)))
-                          ((applySing
-                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                 (sFromInteger (sing :: Sing 11))))
-                             sArg_0123456789876543210)))
-                      ((applySing
-                          ((applySing ((singFun3 @(.@#@$)) (%.)))
-                             ((singFun1 @ShowSpaceSym0) sShowSpace)))
-                         ((applySing
-                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                (sFromInteger (sing :: Sing 11))))
-                            sArg_0123456789876543210))))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Pair ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @(.@#@$) (%.))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun3 @(.@#@$) (%.)) (singFun1 @ShowSpaceSym0 sShowSpace))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210)))))
             sA_0123456789876543210
     deriving instance (Data.Singletons.ShowSing.ShowSing a,
                        Data.Singletons.ShowSing.ShowSing b) =>
                       Show (SPair (z :: Pair a b))
     instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where
-      sing = (SPair sing) sing
+      sing = SPair sing sing
     instance SingI n => SingI1 (Pair (n :: a)) where
       liftSing = SPair sing
     instance SingI2 Pair where
       liftSing2 = SPair
     instance SingI (PairSym0 :: (~>) a ((~>) b (Pair a b))) where
-      sing = (singFun2 @PairSym0) SPair
+      sing = singFun2 @PairSym0 SPair
     instance SingI d =>
              SingI (PairSym1 (d :: a) :: (~>) b (Pair a b)) where
-      sing = (singFun1 @(PairSym1 (d :: a))) (SPair (sing @d))
+      sing = singFun1 @(PairSym1 (d :: a)) (SPair (sing @d))
     instance SingI1 (PairSym1 :: a -> (~>) b (Pair a b)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(PairSym1 (d :: a))) (SPair s)
+        = singFun1 @(PairSym1 (d :: a)) (SPair s)
diff --git a/tests/compile-and-dump/Singletons/Empty.golden b/tests/compile-and-dump/Singletons/Empty.golden
--- a/tests/compile-and-dump/Singletons/Empty.golden
+++ b/tests/compile-and-dump/Singletons/Empty.golden
@@ -6,5 +6,5 @@
     type instance Sing @Empty = SEmpty
     instance SingKind Empty where
       type Demote Empty = Empty
-      fromSing x = case x of {}
-      toSing x = SomeSing (case x of {})
+      fromSing x = (\case) x
+      toSing x = SomeSing ((\case) x)
diff --git a/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden b/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden
--- a/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden
+++ b/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden
@@ -6,68 +6,41 @@
   ======>
     data Foo
     deriving instance Show Foo
-    type family Case_0123456789876543210 v_0123456789876543210 a_0123456789876543210 t where
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> Foo -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Foo) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where
-      ShowsPrec_0123456789876543210 _ v_0123456789876543210 a_0123456789876543210 = Apply (Case_0123456789876543210 v_0123456789876543210 a_0123456789876543210 v_0123456789876543210) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> Foo -> (~>) GHC.Types.Symbol GHC.Types.Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo) :: (~>) GHC.Types.Symbol GHC.Types.Symbol
+    type family LamCases_0123456789876543210 (v_01234567898765432100123456789876543210 :: Foo) (a_01234567898765432100123456789876543210 :: GHC.Internal.Types.Symbol) a_0123456789876543210 where
+    data LamCases_0123456789876543210Sym0 (v_01234567898765432100123456789876543210 :: Foo) (a_01234567898765432100123456789876543210 :: GHC.Internal.Types.Symbol) a_01234567898765432100123456789876543210
       where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> Foo -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (v_01234567898765432100123456789876543210 :: Foo) (a_01234567898765432100123456789876543210 :: GHC.Internal.Types.Symbol) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                          -> Foo
+                                             -> GHC.Internal.Types.Symbol
+                                                -> GHC.Internal.Types.Symbol
+    type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Foo) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where
+      ShowsPrec_0123456789876543210 _ v_0123456789876543210 a_0123456789876543210 = Apply (Apply (LamCases_0123456789876543210Sym0 v_0123456789876543210 a_0123456789876543210) v_0123456789876543210) a_0123456789876543210
     instance PShow Foo where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
     data SFoo :: Foo -> Type
     type instance Sing @Foo = SFoo
     instance SingKind Foo where
       type Demote Foo = Foo
-      fromSing x = case x of {}
-      toSing x = SomeSing (case x of {})
+      fromSing x = (\case) x
+      toSing x = SomeSing ((\case) x)
     instance SShow Foo where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: Foo)
-               (t3 :: GHC.Types.Symbol). Sing t1
-                                         -> Sing t2
-                                            -> Sing t3
-                                               -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-                                                                                              -> Type) t1) t2) t3)
       sShowsPrec
         _
         (sV_0123456789876543210 :: Sing v_0123456789876543210)
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((id
-                 @(Sing (Case_0123456789876543210 v_0123456789876543210 a_0123456789876543210 v_0123456789876543210)))
-                (case sV_0123456789876543210 of {})))
+        = applySing
+            (applySing
+               (singFun1
+                  @(LamCases_0123456789876543210Sym0 v_0123456789876543210 a_0123456789876543210)
+                  (\case))
+               sV_0123456789876543210)
             sA_0123456789876543210
     deriving instance Show (SFoo (z :: Foo))
diff --git a/tests/compile-and-dump/Singletons/EnumDeriving.golden b/tests/compile-and-dump/Singletons/EnumDeriving.golden
--- a/tests/compile-and-dump/Singletons/EnumDeriving.golden
+++ b/tests/compile-and-dump/Singletons/EnumDeriving.golden
@@ -24,52 +24,58 @@
     type Q2Sym0 :: Quux
     type family Q2Sym0 :: Quux where
       Q2Sym0 = Q2
-    type family Case_0123456789876543210 n t where
-      Case_0123456789876543210 n 'True = BumSym0
-      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"
-    type family Case_0123456789876543210 n t where
-      Case_0123456789876543210 n 'True = BazSym0
-      Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 2))
-    type family Case_0123456789876543210 n t where
-      Case_0123456789876543210 n 'True = BarSym0
-      Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1))
-    type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> Foo
-    type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: Foo where
-      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0))
-    type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural Foo
-    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural Foo
+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 n 'True = BumSym0
+      LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"
+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
       where
-        ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>
-                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())
-    type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                           -> Foo
-    type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: Foo where
-      ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210
-    type FromEnum_0123456789876543210 :: Foo -> GHC.Num.Natural.Natural
-    type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Num.Natural.Natural where
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 n 'True = BazSym0
+      LamCases_0123456789876543210 n 'False = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 2))
+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 n 'True = BarSym0
+      LamCases_0123456789876543210 n 'False = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 1))
+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                       -> Foo
+    type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: Foo where
+      ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0))
+    type FromEnum_0123456789876543210 :: Foo
+                                         -> GHC.Internal.Bignum.Natural.Natural
+    type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Internal.Bignum.Natural.Natural where
       FromEnum_0123456789876543210 Bar = FromInteger 0
       FromEnum_0123456789876543210 Baz = FromInteger 1
       FromEnum_0123456789876543210 Bum = FromInteger 2
-    type FromEnum_0123456789876543210Sym0 :: (~>) Foo GHC.Num.Natural.Natural
-    data FromEnum_0123456789876543210Sym0 :: (~>) Foo GHC.Num.Natural.Natural
-      where
-        FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>
-                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())
-    type FromEnum_0123456789876543210Sym1 :: Foo
-                                             -> GHC.Num.Natural.Natural
-    type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Foo) :: GHC.Num.Natural.Natural where
-      FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210
     instance PEnum Foo where
-      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a
-      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a
+      type ToEnum a = ToEnum_0123456789876543210 a
+      type FromEnum a = FromEnum_0123456789876543210 a
     data SFoo :: Foo -> Type
       where
         SBar :: SFoo (Bar :: Foo)
@@ -96,39 +102,37 @@
       toSing Q1 = SomeSing SQ1
       toSing Q2 = SomeSing SQ2
     instance SEnum Foo where
-      sToEnum ::
-        forall (t :: GHC.Num.Natural.Natural). Sing t
-                                               -> Sing (Apply (Data.Singletons.Base.Enum.ToEnumSym0 :: TyFun GHC.Num.Natural.Natural Foo
-                                                                                                       -> Type) t)
-      sFromEnum ::
-        forall (t :: Foo). Sing t
-                           -> Sing (Apply (Data.Singletons.Base.Enum.FromEnumSym0 :: TyFun Foo GHC.Num.Natural.Natural
-                                                                                     -> Type) t)
       sToEnum (sN :: Sing n)
-        = (id
-             @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)))))
-            (case
-                 (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))
-                   (sFromInteger (sing :: Sing 0))
-             of
-               STrue -> SBar
-               SFalse
-                 -> (id
-                       @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1)))))
-                      (case
-                           (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))
-                             (sFromInteger (sing :: Sing 1))
-                       of
-                         STrue -> SBaz
-                         SFalse
-                           -> (id
-                                 @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 2)))))
-                                (case
-                                     (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))
-                                       (sFromInteger (sing :: Sing 2))
-                                 of
-                                   STrue -> SBum
-                                   SFalse -> sError (sing :: Sing "toEnum: bad argument"))))
+        = applySing
+            (singFun1
+               @(LamCases_0123456789876543210Sym0 n)
+               (\cases
+                  STrue -> SBar
+                  SFalse
+                    -> applySing
+                         (singFun1
+                            @(LamCases_0123456789876543210Sym0 n)
+                            (\cases
+                               STrue -> SBaz
+                               SFalse
+                                 -> applySing
+                                      (singFun1
+                                         @(LamCases_0123456789876543210Sym0 n)
+                                         (\cases
+                                            STrue -> SBum
+                                            SFalse
+                                              -> applySing
+                                                   (singFun1 @ErrorSym0 sError)
+                                                   (sing :: Sing "toEnum: bad argument")))
+                                      (applySing
+                                         (applySing (singFun2 @(==@#@$) (%==)) sN)
+                                         (sFromInteger (sing :: Sing 2)))))
+                         (applySing
+                            (applySing (singFun2 @(==@#@$) (%==)) sN)
+                            (sFromInteger (sing :: Sing 1)))))
+            (applySing
+               (applySing (singFun2 @(==@#@$) (%==)) sN)
+               (sFromInteger (sing :: Sing 0)))
       sFromEnum SBar = sFromInteger (sing :: Sing 0)
       sFromEnum SBaz = sFromInteger (sing :: Sing 1)
       sFromEnum SBum = sFromInteger (sing :: Sing 2)
@@ -145,74 +149,66 @@
 Singletons/EnumDeriving.hs:0:0:: Splicing declarations
     singEnumInstance ''Quux
   ======>
-    type family Case_0123456789876543210 n t where
-      Case_0123456789876543210 n 'True = Q2Sym0
-      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"
-    type family Case_0123456789876543210 n t where
-      Case_0123456789876543210 n 'True = Q1Sym0
-      Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1))
-    type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> Quux
-    type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: Quux where
-      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0))
-    type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural Quux
-    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural Quux
+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 n 'True = Q2Sym0
+      LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"
+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
       where
-        ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>
-                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())
-    type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                           -> Quux
-    type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: Quux where
-      ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 n 'True = Q1Sym0
+      LamCases_0123456789876543210 n 'False = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 1))
+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                       -> Quux
+    type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: Quux where
+      ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0))
     type FromEnum_0123456789876543210 :: Quux
-                                         -> GHC.Num.Natural.Natural
-    type family FromEnum_0123456789876543210 (a :: Quux) :: GHC.Num.Natural.Natural where
+                                         -> GHC.Internal.Bignum.Natural.Natural
+    type family FromEnum_0123456789876543210 (a :: Quux) :: GHC.Internal.Bignum.Natural.Natural where
       FromEnum_0123456789876543210 'Q1 = FromInteger 0
       FromEnum_0123456789876543210 'Q2 = FromInteger 1
-    type FromEnum_0123456789876543210Sym0 :: (~>) Quux GHC.Num.Natural.Natural
-    data FromEnum_0123456789876543210Sym0 :: (~>) Quux GHC.Num.Natural.Natural
-      where
-        FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>
-                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())
-    type FromEnum_0123456789876543210Sym1 :: Quux
-                                             -> GHC.Num.Natural.Natural
-    type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Quux) :: GHC.Num.Natural.Natural where
-      FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210
     instance PEnum Quux where
-      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a
-      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a
+      type ToEnum a = ToEnum_0123456789876543210 a
+      type FromEnum a = FromEnum_0123456789876543210 a
     instance SEnum Quux where
-      sToEnum ::
-        forall (t :: GHC.Num.Natural.Natural). Sing t
-                                               -> Sing (Apply (Data.Singletons.Base.Enum.ToEnumSym0 :: TyFun GHC.Num.Natural.Natural Quux
-                                                                                                       -> Type) t)
-      sFromEnum ::
-        forall (t :: Quux). Sing t
-                            -> Sing (Apply (Data.Singletons.Base.Enum.FromEnumSym0 :: TyFun Quux GHC.Num.Natural.Natural
-                                                                                      -> Type) t)
       sToEnum (sN :: Sing n)
-        = (id
-             @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)))))
-            (case
-                 (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))
-                   (sFromInteger (sing :: Sing 0))
-             of
-               STrue -> SQ1
-               SFalse
-                 -> (id
-                       @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1)))))
-                      (case
-                           (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))
-                             (sFromInteger (sing :: Sing 1))
-                       of
-                         STrue -> SQ2
-                         SFalse -> sError (sing :: Sing "toEnum: bad argument")))
+        = applySing
+            (singFun1
+               @(LamCases_0123456789876543210Sym0 n)
+               (\cases
+                  STrue -> SQ1
+                  SFalse
+                    -> applySing
+                         (singFun1
+                            @(LamCases_0123456789876543210Sym0 n)
+                            (\cases
+                               STrue -> SQ2
+                               SFalse
+                                 -> applySing
+                                      (singFun1 @ErrorSym0 sError)
+                                      (sing :: Sing "toEnum: bad argument")))
+                         (applySing
+                            (applySing (singFun2 @(==@#@$) (%==)) sN)
+                            (sFromInteger (sing :: Sing 1)))))
+            (applySing
+               (applySing (singFun2 @(==@#@$) (%==)) sN)
+               (sFromInteger (sing :: Sing 0)))
       sFromEnum SQ1 = sFromInteger (sing :: Sing 0)
       sFromEnum SQ2 = sFromInteger (sing :: Sing 1)
diff --git a/tests/compile-and-dump/Singletons/EqInstances.golden b/tests/compile-and-dump/Singletons/EqInstances.golden
--- a/tests/compile-and-dump/Singletons/EqInstances.golden
+++ b/tests/compile-and-dump/Singletons/EqInstances.golden
@@ -7,35 +7,9 @@
       TFHelper_0123456789876543210 'FLeaf ('(:+:) _ _) = FalseSym0
       TFHelper_0123456789876543210 ('(:+:) _ _) 'FLeaf = FalseSym0
       TFHelper_0123456789876543210 ('(:+:) a_0123456789876543210 a_0123456789876543210) ('(:+:) b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)
-    type TFHelper_0123456789876543210Sym0 :: (~>) Foo ((~>) Foo Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) Foo ((~>) Foo Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Foo -> (~>) Foo Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Foo) :: (~>) Foo Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Foo -> Foo -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Foo) (a0123456789876543210 :: Foo) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PEq Foo where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
+      type (==) a a = TFHelper_0123456789876543210 a a
     instance SEq Foo => SEq Foo where
-      (%==) ::
-        forall (t1 :: Foo) (t2 :: Foo). Sing t1
-                                        -> Sing t2
-                                           -> Sing (Apply (Apply ((==@#@$) :: TyFun Foo ((~>) Foo Bool)
-                                                                              -> Type) t1) t2)
       (%==) SFLeaf SFLeaf = STrue
       (%==) SFLeaf ((:%+:) _ _) = SFalse
       (%==) ((:%+:) _ _) SFLeaf = SFalse
@@ -44,44 +18,19 @@
                 (sA_0123456789876543210 :: Sing a_0123456789876543210))
         ((:%+:) (sB_0123456789876543210 :: Sing b_0123456789876543210)
                 (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                ((applySing
-                    ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                   sB_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @(&&@#@$) (%&&))
+               (applySing
+                  (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                  sB_0123456789876543210))
+            (applySing
+               (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
                sB_0123456789876543210)
     type TFHelper_0123456789876543210 :: Empty -> Empty -> Bool
     type family TFHelper_0123456789876543210 (a :: Empty) (a :: Empty) :: Bool where
       TFHelper_0123456789876543210 _ _ = TrueSym0
-    type TFHelper_0123456789876543210Sym0 :: (~>) Empty ((~>) Empty Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) Empty ((~>) Empty Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Empty -> (~>) Empty Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Empty) :: (~>) Empty Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Empty -> Empty -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Empty) (a0123456789876543210 :: Empty) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PEq Empty where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
+      type (==) a a = TFHelper_0123456789876543210 a a
     instance SEq Empty where
-      (%==) ::
-        forall (t1 :: Empty) (t2 :: Empty). Sing t1
-                                            -> Sing t2
-                                               -> Sing (Apply (Apply ((==@#@$) :: TyFun Empty ((~>) Empty Bool)
-                                                                                  -> Type) t1) t2)
       (%==) _ _ = STrue
diff --git a/tests/compile-and-dump/Singletons/Error.golden b/tests/compile-and-dump/Singletons/Error.golden
--- a/tests/compile-and-dump/Singletons/Error.golden
+++ b/tests/compile-and-dump/Singletons/Error.golden
@@ -12,19 +12,20 @@
       where
         HeadSym0KindInference :: SameKind (Apply HeadSym0 arg) (HeadSym1 arg) =>
                                  HeadSym0 a0123456789876543210
-    type instance Apply HeadSym0 a0123456789876543210 = Head a0123456789876543210
+    type instance Apply @[a] @a HeadSym0 a0123456789876543210 = Head a0123456789876543210
     instance SuppressUnusedWarnings HeadSym0 where
-      suppressUnusedWarnings = snd (((,) HeadSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) HeadSym0KindInference ())
     type HeadSym1 :: [a] -> a
-    type family HeadSym1 (a0123456789876543210 :: [a]) :: a where
+    type family HeadSym1 @a (a0123456789876543210 :: [a]) :: a where
       HeadSym1 a0123456789876543210 = Head a0123456789876543210
     type Head :: [a] -> a
-    type family Head (a :: [a]) :: a where
+    type family Head @a (a :: [a]) :: a where
       Head ('(:) a _) = a
       Head '[] = Apply ErrorSym0 "head: empty list"
-    sHead ::
-      forall a (t :: [a]). Sing t -> Sing (Apply HeadSym0 t :: a)
+    sHead :: (forall (t :: [a]). Sing t -> Sing (Head t :: a) :: Type)
     sHead (SCons (sA :: Sing a) _) = sA
-    sHead SNil = sError (sing :: Sing "head: empty list")
+    sHead SNil
+      = applySing
+          (singFun1 @ErrorSym0 sError) (sing :: Sing "head: empty list")
     instance SingI (HeadSym0 :: (~>) [a] a) where
-      sing = (singFun1 @HeadSym0) sHead
+      sing = singFun1 @HeadSym0 sHead
diff --git a/tests/compile-and-dump/Singletons/Fixity.golden b/tests/compile-and-dump/Singletons/Fixity.golden
--- a/tests/compile-and-dump/Singletons/Fixity.golden
+++ b/tests/compile-and-dump/Singletons/Fixity.golden
@@ -20,74 +20,74 @@
       where
         (:====@#@$###) :: SameKind (Apply (====@#@$) arg) ((====@#@$$) arg) =>
                           (====@#@$) a0123456789876543210
-    type instance Apply (====@#@$) a0123456789876543210 = (====@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) a a) (====@#@$) a0123456789876543210 = (====@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (====@#@$) where
-      suppressUnusedWarnings = snd (((,) (:====@#@$###)) ())
-    infix 4 ====@#@$
+      suppressUnusedWarnings = snd ((,) (:====@#@$###) ())
+    infix 4 type ====@#@$
     type (====@#@$$) :: a -> (~>) a a
     data (====@#@$$) (a0123456789876543210 :: a) :: (~>) a a
       where
         (:====@#@$$###) :: SameKind (Apply ((====@#@$$) a0123456789876543210) arg) ((====@#@$$$) a0123456789876543210 arg) =>
                            (====@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((====@#@$$) a0123456789876543210) a0123456789876543210 = (====) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @a ((====@#@$$) a0123456789876543210) a0123456789876543210 = (====) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((====@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:====@#@$$###)) ())
-    infix 4 ====@#@$$
+      suppressUnusedWarnings = snd ((,) (:====@#@$$###) ())
+    infix 4 type ====@#@$$
     type (====@#@$$$) :: a -> a -> a
-    type family (====@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
+    type family (====@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
       (====@#@$$$) a0123456789876543210 a0123456789876543210 = (====) a0123456789876543210 a0123456789876543210
-    infix 4 ====@#@$$$
+    infix 4 type ====@#@$$$
     type (====) :: a -> a -> a
-    type family (====) (a :: a) (a :: a) :: a where
+    type family (====) @a (a :: a) (a :: a) :: a where
       (====) a _ = a
     type (<=>@#@$) :: forall a. (~>) a ((~>) a Ordering)
     data (<=>@#@$) :: (~>) a ((~>) a Ordering)
       where
         (:<=>@#@$###) :: SameKind (Apply (<=>@#@$) arg) ((<=>@#@$$) arg) =>
                          (<=>@#@$) a0123456789876543210
-    type instance Apply (<=>@#@$) a0123456789876543210 = (<=>@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) a Ordering) (<=>@#@$) a0123456789876543210 = (<=>@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (<=>@#@$) where
-      suppressUnusedWarnings = snd (((,) (:<=>@#@$###)) ())
-    infix 4 <=>@#@$
+      suppressUnusedWarnings = snd ((,) (:<=>@#@$###) ())
+    infix 4 type <=>@#@$
     type (<=>@#@$$) :: forall a. a -> (~>) a Ordering
     data (<=>@#@$$) (a0123456789876543210 :: a) :: (~>) a Ordering
       where
         (:<=>@#@$$###) :: SameKind (Apply ((<=>@#@$$) a0123456789876543210) arg) ((<=>@#@$$$) a0123456789876543210 arg) =>
                           (<=>@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((<=>@#@$$) a0123456789876543210) a0123456789876543210 = (<=>) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @Ordering ((<=>@#@$$) a0123456789876543210) a0123456789876543210 = (<=>) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((<=>@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:<=>@#@$$###)) ())
-    infix 4 <=>@#@$$
+      suppressUnusedWarnings = snd ((,) (:<=>@#@$$###) ())
+    infix 4 type <=>@#@$$
     type (<=>@#@$$$) :: forall a. a -> a -> Ordering
-    type family (<=>@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ordering where
+    type family (<=>@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ordering where
       (<=>@#@$$$) a0123456789876543210 a0123456789876543210 = (<=>) a0123456789876543210 a0123456789876543210
-    infix 4 <=>@#@$$$
+    infix 4 type <=>@#@$$$
     class PMyOrd a where
       type family (<=>) (arg :: a) (arg :: a) :: Ordering
-    infix 4 %====
+    infix 4 data %====
     (%====) ::
-      forall a (t :: a) (t :: a). Sing t
-                                  -> Sing t -> Sing (Apply (Apply (====@#@$) t) t :: a)
+      (forall (t :: a) (t :: a).
+       Sing t -> Sing t -> Sing ((====) t t :: a) :: Type)
     (%====) (sA :: Sing a) _ = sA
     instance SingI ((====@#@$) :: (~>) a ((~>) a a)) where
-      sing = (singFun2 @(====@#@$)) (%====)
+      sing = singFun2 @(====@#@$) (%====)
     instance SingI d => SingI ((====@#@$$) (d :: a) :: (~>) a a) where
-      sing = (singFun1 @((====@#@$$) (d :: a))) ((%====) (sing @d))
+      sing = singFun1 @((====@#@$$) (d :: a)) ((%====) (sing @d))
     instance SingI1 ((====@#@$$) :: a -> (~>) a a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((====@#@$$) (d :: a))) ((%====) s)
+        = singFun1 @((====@#@$$) (d :: a)) ((%====) s)
     class SMyOrd a where
       (%<=>) ::
-        forall (t :: a) (t :: a). Sing t
-                                  -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering)
-      infix 4 %<=>
+        (forall (t :: a) (t :: a).
+         Sing t -> Sing t -> Sing ((<=>) t t :: Ordering) :: Type)
+      infix 4 data %<=>
     instance SMyOrd a =>
              SingI ((<=>@#@$) :: (~>) a ((~>) a Ordering)) where
-      sing = (singFun2 @(<=>@#@$)) (%<=>)
+      sing = singFun2 @(<=>@#@$) (%<=>)
     instance (SMyOrd a, SingI d) =>
              SingI ((<=>@#@$$) (d :: a) :: (~>) a Ordering) where
-      sing = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) (sing @d))
+      sing = singFun1 @((<=>@#@$$) (d :: a)) ((%<=>) (sing @d))
     instance SMyOrd a =>
              SingI1 ((<=>@#@$$) :: a -> (~>) a Ordering) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) s)
+        = singFun1 @((<=>@#@$$) (d :: a)) ((%<=>) s)
diff --git a/tests/compile-and-dump/Singletons/FunDeps.golden b/tests/compile-and-dump/Singletons/FunDeps.golden
--- a/tests/compile-and-dump/Singletons/FunDeps.golden
+++ b/tests/compile-and-dump/Singletons/FunDeps.golden
@@ -28,22 +28,22 @@
       where
         MethSym0KindInference :: SameKind (Apply MethSym0 arg) (MethSym1 arg) =>
                                  MethSym0 a0123456789876543210
-    type instance Apply MethSym0 a0123456789876543210 = Meth a0123456789876543210
+    type instance Apply @a @a MethSym0 a0123456789876543210 = Meth a0123456789876543210
     instance SuppressUnusedWarnings MethSym0 where
-      suppressUnusedWarnings = snd (((,) MethSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MethSym0KindInference ())
     type MethSym1 :: forall a. a -> a
-    type family MethSym1 (a0123456789876543210 :: a) :: a where
+    type family MethSym1 @a (a0123456789876543210 :: a) :: a where
       MethSym1 a0123456789876543210 = Meth a0123456789876543210
     type L2rSym0 :: forall a b. (~>) a b
     data L2rSym0 :: (~>) a b
       where
         L2rSym0KindInference :: SameKind (Apply L2rSym0 arg) (L2rSym1 arg) =>
                                 L2rSym0 a0123456789876543210
-    type instance Apply L2rSym0 a0123456789876543210 = L2r a0123456789876543210
+    type instance Apply @a @b L2rSym0 a0123456789876543210 = L2r a0123456789876543210
     instance SuppressUnusedWarnings L2rSym0 where
-      suppressUnusedWarnings = snd (((,) L2rSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) L2rSym0KindInference ())
     type L2rSym1 :: forall a b. a -> b
-    type family L2rSym1 (a0123456789876543210 :: a) :: b where
+    type family L2rSym1 @a @b (a0123456789876543210 :: a) :: b where
       L2rSym1 a0123456789876543210 = L2r a0123456789876543210
     class PFD a b | a -> b where
       type family Meth (arg :: a) :: a
@@ -51,52 +51,24 @@
     type Meth_0123456789876543210 :: Bool -> Bool
     type family Meth_0123456789876543210 (a :: Bool) :: Bool where
       Meth_0123456789876543210 a_0123456789876543210 = Apply NotSym0 a_0123456789876543210
-    type Meth_0123456789876543210Sym0 :: (~>) Bool Bool
-    data Meth_0123456789876543210Sym0 :: (~>) Bool Bool
-      where
-        Meth_0123456789876543210Sym0KindInference :: SameKind (Apply Meth_0123456789876543210Sym0 arg) (Meth_0123456789876543210Sym1 arg) =>
-                                                     Meth_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Meth_0123456789876543210Sym0 a0123456789876543210 = Meth_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings Meth_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Meth_0123456789876543210Sym0KindInference) ())
-    type Meth_0123456789876543210Sym1 :: Bool -> Bool
-    type family Meth_0123456789876543210Sym1 (a0123456789876543210 :: Bool) :: Bool where
-      Meth_0123456789876543210Sym1 a0123456789876543210 = Meth_0123456789876543210 a0123456789876543210
     type L2r_0123456789876543210 :: Bool -> Natural
     type family L2r_0123456789876543210 (a :: Bool) :: Natural where
       L2r_0123456789876543210 'False = FromInteger 0
       L2r_0123456789876543210 'True = FromInteger 1
-    type L2r_0123456789876543210Sym0 :: (~>) Bool Natural
-    data L2r_0123456789876543210Sym0 :: (~>) Bool Natural
-      where
-        L2r_0123456789876543210Sym0KindInference :: SameKind (Apply L2r_0123456789876543210Sym0 arg) (L2r_0123456789876543210Sym1 arg) =>
-                                                    L2r_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply L2r_0123456789876543210Sym0 a0123456789876543210 = L2r_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings L2r_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) L2r_0123456789876543210Sym0KindInference) ())
-    type L2r_0123456789876543210Sym1 :: Bool -> Natural
-    type family L2r_0123456789876543210Sym1 (a0123456789876543210 :: Bool) :: Natural where
-      L2r_0123456789876543210Sym1 a0123456789876543210 = L2r_0123456789876543210 a0123456789876543210
     instance PFD Bool Natural where
-      type Meth a = Apply Meth_0123456789876543210Sym0 a
-      type L2r a = Apply L2r_0123456789876543210Sym0 a
-    sT1 :: Sing @_ T1Sym0
-    sT1 = (applySing ((singFun1 @MethSym0) sMeth)) STrue
+      type Meth a = Meth_0123456789876543210 a
+      type L2r a = L2r_0123456789876543210 a
+    sT1 :: Sing @_ T1
+    sT1 = applySing (singFun1 @MethSym0 sMeth) STrue
     class SFD a b | a -> b where
-      sMeth :: forall (t :: a). Sing t -> Sing (Apply MethSym0 t :: a)
-      sL2r :: forall (t :: a). Sing t -> Sing (Apply L2rSym0 t :: b)
+      sMeth :: (forall (t :: a). Sing t -> Sing (Meth t :: a) :: Type)
+      sL2r :: (forall (t :: a). Sing t -> Sing (L2r t :: b) :: Type)
     instance SFD Bool Natural where
-      sMeth ::
-        forall (t :: Bool). Sing t -> Sing (Apply MethSym0 t :: Bool)
-      sL2r ::
-        forall (t :: Bool). Sing t -> Sing (Apply L2rSym0 t :: Natural)
       sMeth (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing ((singFun1 @NotSym0) sNot)) sA_0123456789876543210
+        = applySing (singFun1 @NotSym0 sNot) sA_0123456789876543210
       sL2r SFalse = sFromInteger (sing :: Sing 0)
       sL2r STrue = sFromInteger (sing :: Sing 1)
     instance SFD a b => SingI (MethSym0 :: (~>) a a) where
-      sing = (singFun1 @MethSym0) sMeth
+      sing = singFun1 @MethSym0 sMeth
     instance SFD a b => SingI (L2rSym0 :: (~>) a b) where
-      sing = (singFun1 @L2rSym0) sL2r
+      sing = singFun1 @L2rSym0 sL2r
diff --git a/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden b/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden
--- a/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden
+++ b/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden
@@ -15,1359 +15,667 @@
       where
         MkT1Sym0KindInference :: SameKind (Apply MkT1Sym0 arg) (MkT1Sym1 arg) =>
                                  MkT1Sym0 a0123456789876543210
-    type instance Apply MkT1Sym0 a0123456789876543210 = MkT1Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings MkT1Sym0 where
-      suppressUnusedWarnings = snd (((,) MkT1Sym0KindInference) ())
-    type MkT1Sym1 :: forall x a. x
-                                 -> (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))
-    data MkT1Sym1 (a0123456789876543210 :: x) :: (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))
-      where
-        MkT1Sym1KindInference :: SameKind (Apply (MkT1Sym1 a0123456789876543210) arg) (MkT1Sym2 a0123456789876543210 arg) =>
-                                 MkT1Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkT1Sym1 a0123456789876543210) a0123456789876543210 = MkT1Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (MkT1Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkT1Sym1KindInference) ())
-    type MkT1Sym2 :: forall x a. x
-                                 -> a -> (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))
-    data MkT1Sym2 (a0123456789876543210 :: x) (a0123456789876543210 :: a) :: (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))
-      where
-        MkT1Sym2KindInference :: SameKind (Apply (MkT1Sym2 a0123456789876543210 a0123456789876543210) arg) (MkT1Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                 MkT1Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkT1Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (MkT1Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkT1Sym2KindInference) ())
-    type MkT1Sym3 :: forall x a. x
-                                 -> a -> Maybe a -> (~>) (Maybe (Maybe a)) (T x a)
-    data MkT1Sym3 (a0123456789876543210 :: x) (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) :: (~>) (Maybe (Maybe a)) (T x a)
-      where
-        MkT1Sym3KindInference :: SameKind (Apply (MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (MkT1Sym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
-                                 MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = MkT1 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkT1Sym3KindInference) ())
-    type MkT1Sym4 :: forall x a. x
-                                 -> a -> Maybe a -> Maybe (Maybe a) -> T x a
-    type family MkT1Sym4 (a0123456789876543210 :: x) (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) (a0123456789876543210 :: Maybe (Maybe a)) :: T x a where
-      MkT1Sym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = MkT1 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type MkT2Sym0 :: forall x a. (~>) (Maybe x) (T x a)
-    data MkT2Sym0 :: (~>) (Maybe x) (T x a)
-      where
-        MkT2Sym0KindInference :: SameKind (Apply MkT2Sym0 arg) (MkT2Sym1 arg) =>
-                                 MkT2Sym0 a0123456789876543210
-    type instance Apply MkT2Sym0 a0123456789876543210 = MkT2 a0123456789876543210
-    instance SuppressUnusedWarnings MkT2Sym0 where
-      suppressUnusedWarnings = snd (((,) MkT2Sym0KindInference) ())
-    type MkT2Sym1 :: forall x a. Maybe x -> T x a
-    type family MkT2Sym1 (a0123456789876543210 :: Maybe x) :: T x a where
-      MkT2Sym1 a0123456789876543210 = MkT2 a0123456789876543210
-    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 where
-      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210
-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym4KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())
-    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym5KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())
-    type family Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 n_0123456789876543210 where
-      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210
-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type Fmap_0123456789876543210 :: (~>) a b -> T x a -> T x b
-    type family Fmap_0123456789876543210 (a :: (~>) a b) (a :: T x a) :: T x b where
-      Fmap_0123456789876543210 _f_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply (Apply (Apply MkT1Sym0 (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (Apply _f_0123456789876543210 a_0123456789876543210)) (Apply (Apply FmapSym0 _f_0123456789876543210) a_0123456789876543210)) (Apply (Apply FmapSym0 (Apply FmapSym0 _f_0123456789876543210)) a_0123456789876543210)
-      Fmap_0123456789876543210 _f_0123456789876543210 (MkT2 a_0123456789876543210) = Apply MkT2Sym0 (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210)
-    type Fmap_0123456789876543210Sym0 :: (~>) ((~>) a b) ((~>) (T x a) (T x b))
-    data Fmap_0123456789876543210Sym0 :: (~>) ((~>) a b) ((~>) (T x a) (T x b))
-      where
-        Fmap_0123456789876543210Sym0KindInference :: SameKind (Apply Fmap_0123456789876543210Sym0 arg) (Fmap_0123456789876543210Sym1 arg) =>
-                                                     Fmap_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Fmap_0123456789876543210Sym0 a0123456789876543210 = Fmap_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Fmap_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Fmap_0123456789876543210Sym0KindInference) ())
-    type Fmap_0123456789876543210Sym1 :: (~>) a b
-                                         -> (~>) (T x a) (T x b)
-    data Fmap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a b) :: (~>) (T x a) (T x b)
-      where
-        Fmap_0123456789876543210Sym1KindInference :: SameKind (Apply (Fmap_0123456789876543210Sym1 a0123456789876543210) arg) (Fmap_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                     Fmap_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Fmap_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Fmap_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Fmap_0123456789876543210Sym1KindInference) ())
-    type Fmap_0123456789876543210Sym2 :: (~>) a b -> T x a -> T x b
-    type family Fmap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: T x a) :: T x b where
-      Fmap_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210
-    type family Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 where
-      Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210
-    data Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    data Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym4KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())
-    data Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym5KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym6 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())
-    type family Lambda_0123456789876543210Sym6 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym6 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 where
-      Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = _z_0123456789876543210
-    data Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    data Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym4KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())
-    data Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym5KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym6 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())
-    type family Lambda_0123456789876543210Sym6 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym6 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 n_0123456789876543210 where
-      Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210
-    data Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type TFHelper_0123456789876543210 :: a -> T x b -> T x a
-    type family TFHelper_0123456789876543210 (a :: a) (a :: T x b) :: T x a where
-      TFHelper_0123456789876543210 _z_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply (Apply (Apply MkT1Sym0 (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (Apply (Apply (<$@#@$) _z_0123456789876543210) a_0123456789876543210)) (Apply (Apply FmapSym0 (Apply (<$@#@$) _z_0123456789876543210)) a_0123456789876543210)
-      TFHelper_0123456789876543210 _z_0123456789876543210 (MkT2 a_0123456789876543210) = Apply MkT2Sym0 (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210)
-    type TFHelper_0123456789876543210Sym0 :: (~>) a ((~>) (T x b) (T x a))
-    data TFHelper_0123456789876543210Sym0 :: (~>) a ((~>) (T x b) (T x a))
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: a -> (~>) (T x b) (T x a)
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: a) :: (~>) (T x b) (T x a)
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: a -> T x b -> T x a
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: T x b) :: T x a where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PFunctor (T x) where
-      type Fmap a a = Apply (Apply Fmap_0123456789876543210Sym0 a) a
-      type (<$) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 where
-      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = MemptySym0
-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym4KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())
-    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym5KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())
-    type family Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 n_0123456789876543210 where
-      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = MemptySym0
-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type FoldMap_0123456789876543210 :: (~>) a m -> T x a -> m
-    type family FoldMap_0123456789876543210 (a :: (~>) a m) (a :: T x a) :: m where
-      FoldMap_0123456789876543210 _f_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply MappendSym0 (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (Apply (Apply MappendSym0 (Apply _f_0123456789876543210 a_0123456789876543210)) (Apply (Apply MappendSym0 (Apply (Apply FoldMapSym0 _f_0123456789876543210) a_0123456789876543210)) (Apply (Apply FoldMapSym0 (Apply FoldMapSym0 _f_0123456789876543210)) a_0123456789876543210)))
-      FoldMap_0123456789876543210 _f_0123456789876543210 (MkT2 a_0123456789876543210) = Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210
-    type FoldMap_0123456789876543210Sym0 :: (~>) ((~>) a m) ((~>) (T x a) m)
-    data FoldMap_0123456789876543210Sym0 :: (~>) ((~>) a m) ((~>) (T x a) m)
-      where
-        FoldMap_0123456789876543210Sym0KindInference :: SameKind (Apply FoldMap_0123456789876543210Sym0 arg) (FoldMap_0123456789876543210Sym1 arg) =>
-                                                        FoldMap_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply FoldMap_0123456789876543210Sym0 a0123456789876543210 = FoldMap_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings FoldMap_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) FoldMap_0123456789876543210Sym0KindInference) ())
-    type FoldMap_0123456789876543210Sym1 :: (~>) a m -> (~>) (T x a) m
-    data FoldMap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a m) :: (~>) (T x a) m
-      where
-        FoldMap_0123456789876543210Sym1KindInference :: SameKind (Apply (FoldMap_0123456789876543210Sym1 a0123456789876543210) arg) (FoldMap_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        FoldMap_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FoldMap_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = FoldMap_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (FoldMap_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) FoldMap_0123456789876543210Sym1KindInference) ())
-    type FoldMap_0123456789876543210Sym2 :: (~>) a m -> T x a -> m
-    type family FoldMap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a m) (a0123456789876543210 :: T x a) :: m where
-      FoldMap_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = FoldMap_0123456789876543210 a0123456789876543210 a0123456789876543210
-    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 where
-      Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = n2_0123456789876543210
-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym4KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())
-    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym5KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())
-    data Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym6KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n1_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())
-    data Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym7KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())
-    type family Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 where
-      Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = Apply (Apply (Apply FoldrSym0 _f_0123456789876543210) n2_0123456789876543210) n1_0123456789876543210
-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym4KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())
-    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym5KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())
-    data Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym6KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n1_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())
-    data Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym7KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())
-    type family Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 where
-      Lambda_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = Apply (Apply (Apply FoldrSym0 _f_0123456789876543210) n2_0123456789876543210) n1_0123456789876543210
-    data Lambda_0123456789876543210Sym0 n1_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 n1_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 n1_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 n1_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 n1_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 n1_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 n1_01234567898765432100123456789876543210) n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 n1_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210) _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym4 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    data Lambda_0123456789876543210Sym4 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym4KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym4 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym5 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym4 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym4 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())
-    data Lambda_0123456789876543210Sym5 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym5KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym5 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym6 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym5 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym5 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())
-    data Lambda_0123456789876543210Sym6 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym6KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym6 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym7 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym6 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym6 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym7 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())
-    data Lambda_0123456789876543210Sym7 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym7KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym7 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym8 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym7 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym7 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym8 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())
-    data Lambda_0123456789876543210Sym8 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym8KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym8 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym9 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym8 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym8 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n1_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym9 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym8 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym8KindInference) ())
-    data Lambda_0123456789876543210Sym9 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym9KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym9 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym10 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym9 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym9 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym9 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym9KindInference) ())
-    type family Lambda_0123456789876543210Sym10 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym10 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 where
-      Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = Apply (Apply (Apply FoldrSym0 (Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 n1_0123456789876543210) n2_0123456789876543210) _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) n2_0123456789876543210) n1_0123456789876543210
-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym4KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())
-    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym5KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())
-    data Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym6KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n1_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())
-    data Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym7KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())
-    type family Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 where
-      Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = n2_0123456789876543210
-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n1_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym4KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())
-    type family Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type Foldr_0123456789876543210 :: (~>) a ((~>) b b)
-                                      -> b -> T x a -> b
-    type family Foldr_0123456789876543210 (a :: (~>) a ((~>) b b)) (a :: b) (a :: T x a) :: b where
-      Foldr_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) (Apply (Apply _f_0123456789876543210 a_0123456789876543210) (Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) (Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) _z_0123456789876543210)))
-      Foldr_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 (MkT2 a_0123456789876543210) = Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) _z_0123456789876543210
-    type Foldr_0123456789876543210Sym0 :: (~>) ((~>) a ((~>) b b)) ((~>) b ((~>) (T x a) b))
-    data Foldr_0123456789876543210Sym0 :: (~>) ((~>) a ((~>) b b)) ((~>) b ((~>) (T x a) b))
-      where
-        Foldr_0123456789876543210Sym0KindInference :: SameKind (Apply Foldr_0123456789876543210Sym0 arg) (Foldr_0123456789876543210Sym1 arg) =>
-                                                      Foldr_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Foldr_0123456789876543210Sym0 a0123456789876543210 = Foldr_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Foldr_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Foldr_0123456789876543210Sym0KindInference) ())
-    type Foldr_0123456789876543210Sym1 :: (~>) a ((~>) b b)
-                                          -> (~>) b ((~>) (T x a) b)
-    data Foldr_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a ((~>) b b)) :: (~>) b ((~>) (T x a) b)
-      where
-        Foldr_0123456789876543210Sym1KindInference :: SameKind (Apply (Foldr_0123456789876543210Sym1 a0123456789876543210) arg) (Foldr_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                      Foldr_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foldr_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Foldr_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Foldr_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Foldr_0123456789876543210Sym1KindInference) ())
-    type Foldr_0123456789876543210Sym2 :: (~>) a ((~>) b b)
-                                          -> b -> (~>) (T x a) b
-    data Foldr_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a ((~>) b b)) (a0123456789876543210 :: b) :: (~>) (T x a) b
-      where
-        Foldr_0123456789876543210Sym2KindInference :: SameKind (Apply (Foldr_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (Foldr_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                      Foldr_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foldr_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = Foldr_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Foldr_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Foldr_0123456789876543210Sym2KindInference) ())
-    type Foldr_0123456789876543210Sym3 :: (~>) a ((~>) b b)
-                                          -> b -> T x a -> b
-    type family Foldr_0123456789876543210Sym3 (a0123456789876543210 :: (~>) a ((~>) b b)) (a0123456789876543210 :: b) (a0123456789876543210 :: T x a) :: b where
-      Foldr_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = Foldr_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PFoldable (T x) where
-      type FoldMap a a = Apply (Apply FoldMap_0123456789876543210Sym0 a) a
-      type Foldr a a a = Apply (Apply (Apply Foldr_0123456789876543210Sym0 a) a) a
-    type Traverse_0123456789876543210 :: (~>) a (f b)
-                                         -> T x a -> f (T x b)
-    type family Traverse_0123456789876543210 (a :: (~>) a (f b)) (a :: T x a) :: f (T x b) where
-      Traverse_0123456789876543210 _f_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply (<*>@#@$) (Apply (Apply (<*>@#@$) (Apply (Apply (Apply LiftA2Sym0 MkT1Sym0) (Apply PureSym0 a_0123456789876543210)) (Apply _f_0123456789876543210 a_0123456789876543210))) (Apply (Apply TraverseSym0 _f_0123456789876543210) a_0123456789876543210))) (Apply (Apply TraverseSym0 (Apply TraverseSym0 _f_0123456789876543210)) a_0123456789876543210)
-      Traverse_0123456789876543210 _f_0123456789876543210 (MkT2 a_0123456789876543210) = Apply (Apply FmapSym0 MkT2Sym0) (Apply PureSym0 a_0123456789876543210)
-    type Traverse_0123456789876543210Sym0 :: (~>) ((~>) a (f b)) ((~>) (T x a) (f (T x b)))
-    data Traverse_0123456789876543210Sym0 :: (~>) ((~>) a (f b)) ((~>) (T x a) (f (T x b)))
-      where
-        Traverse_0123456789876543210Sym0KindInference :: SameKind (Apply Traverse_0123456789876543210Sym0 arg) (Traverse_0123456789876543210Sym1 arg) =>
-                                                         Traverse_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Traverse_0123456789876543210Sym0 a0123456789876543210 = Traverse_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Traverse_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Traverse_0123456789876543210Sym0KindInference) ())
-    type Traverse_0123456789876543210Sym1 :: (~>) a (f b)
-                                             -> (~>) (T x a) (f (T x b))
-    data Traverse_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a (f b)) :: (~>) (T x a) (f (T x b))
-      where
-        Traverse_0123456789876543210Sym1KindInference :: SameKind (Apply (Traverse_0123456789876543210Sym1 a0123456789876543210) arg) (Traverse_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         Traverse_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Traverse_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Traverse_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Traverse_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Traverse_0123456789876543210Sym1KindInference) ())
-    type Traverse_0123456789876543210Sym2 :: (~>) a (f b)
-                                             -> T x a -> f (T x b)
-    type family Traverse_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a (f b)) (a0123456789876543210 :: T x a) :: f (T x b) where
-      Traverse_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Traverse_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PTraversable (T x) where
-      type Traverse a a = Apply (Apply Traverse_0123456789876543210Sym0 a) a
-    type family Case_0123456789876543210 v_0123456789876543210 t where
-    type Fmap_0123456789876543210 :: (~>) a b -> Empty a -> Empty b
-    type family Fmap_0123456789876543210 (a :: (~>) a b) (a :: Empty a) :: Empty b where
-      Fmap_0123456789876543210 _ v_0123456789876543210 = Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210
-    type Fmap_0123456789876543210Sym0 :: (~>) ((~>) a b) ((~>) (Empty a) (Empty b))
-    data Fmap_0123456789876543210Sym0 :: (~>) ((~>) a b) ((~>) (Empty a) (Empty b))
-      where
-        Fmap_0123456789876543210Sym0KindInference :: SameKind (Apply Fmap_0123456789876543210Sym0 arg) (Fmap_0123456789876543210Sym1 arg) =>
-                                                     Fmap_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Fmap_0123456789876543210Sym0 a0123456789876543210 = Fmap_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Fmap_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Fmap_0123456789876543210Sym0KindInference) ())
-    type Fmap_0123456789876543210Sym1 :: (~>) a b
-                                         -> (~>) (Empty a) (Empty b)
-    data Fmap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a b) :: (~>) (Empty a) (Empty b)
-      where
-        Fmap_0123456789876543210Sym1KindInference :: SameKind (Apply (Fmap_0123456789876543210Sym1 a0123456789876543210) arg) (Fmap_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                     Fmap_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Fmap_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Fmap_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Fmap_0123456789876543210Sym1KindInference) ())
-    type Fmap_0123456789876543210Sym2 :: (~>) a b -> Empty a -> Empty b
-    type family Fmap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: Empty a) :: Empty b where
-      Fmap_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210
-    type family Case_0123456789876543210 v_0123456789876543210 t where
-    type TFHelper_0123456789876543210 :: a -> Empty b -> Empty a
-    type family TFHelper_0123456789876543210 (a :: a) (a :: Empty b) :: Empty a where
-      TFHelper_0123456789876543210 _ v_0123456789876543210 = Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210
-    type TFHelper_0123456789876543210Sym0 :: (~>) a ((~>) (Empty b) (Empty a))
-    data TFHelper_0123456789876543210Sym0 :: (~>) a ((~>) (Empty b) (Empty a))
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: a
-                                             -> (~>) (Empty b) (Empty a)
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: a) :: (~>) (Empty b) (Empty a)
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: a -> Empty b -> Empty a
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: Empty b) :: Empty a where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PFunctor Empty where
-      type Fmap a a = Apply (Apply Fmap_0123456789876543210Sym0 a) a
-      type (<$) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type FoldMap_0123456789876543210 :: (~>) a m -> Empty a -> m
-    type family FoldMap_0123456789876543210 (a :: (~>) a m) (a :: Empty a) :: m where
-      FoldMap_0123456789876543210 _ _ = MemptySym0
-    type FoldMap_0123456789876543210Sym0 :: (~>) ((~>) a m) ((~>) (Empty a) m)
-    data FoldMap_0123456789876543210Sym0 :: (~>) ((~>) a m) ((~>) (Empty a) m)
-      where
-        FoldMap_0123456789876543210Sym0KindInference :: SameKind (Apply FoldMap_0123456789876543210Sym0 arg) (FoldMap_0123456789876543210Sym1 arg) =>
-                                                        FoldMap_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply FoldMap_0123456789876543210Sym0 a0123456789876543210 = FoldMap_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings FoldMap_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) FoldMap_0123456789876543210Sym0KindInference) ())
-    type FoldMap_0123456789876543210Sym1 :: (~>) a m
-                                            -> (~>) (Empty a) m
-    data FoldMap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a m) :: (~>) (Empty a) m
-      where
-        FoldMap_0123456789876543210Sym1KindInference :: SameKind (Apply (FoldMap_0123456789876543210Sym1 a0123456789876543210) arg) (FoldMap_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        FoldMap_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FoldMap_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = FoldMap_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (FoldMap_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) FoldMap_0123456789876543210Sym1KindInference) ())
-    type FoldMap_0123456789876543210Sym2 :: (~>) a m -> Empty a -> m
-    type family FoldMap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a m) (a0123456789876543210 :: Empty a) :: m where
-      FoldMap_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = FoldMap_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PFoldable Empty where
-      type FoldMap a a = Apply (Apply FoldMap_0123456789876543210Sym0 a) a
-    type family Case_0123456789876543210 v_0123456789876543210 t where
-    type Traverse_0123456789876543210 :: (~>) a (f b)
-                                         -> Empty a -> f (Empty b)
-    type family Traverse_0123456789876543210 (a :: (~>) a (f b)) (a :: Empty a) :: f (Empty b) where
-      Traverse_0123456789876543210 _ v_0123456789876543210 = Apply PureSym0 (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)
-    type Traverse_0123456789876543210Sym0 :: (~>) ((~>) a (f b)) ((~>) (Empty a) (f (Empty b)))
-    data Traverse_0123456789876543210Sym0 :: (~>) ((~>) a (f b)) ((~>) (Empty a) (f (Empty b)))
-      where
-        Traverse_0123456789876543210Sym0KindInference :: SameKind (Apply Traverse_0123456789876543210Sym0 arg) (Traverse_0123456789876543210Sym1 arg) =>
-                                                         Traverse_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Traverse_0123456789876543210Sym0 a0123456789876543210 = Traverse_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Traverse_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Traverse_0123456789876543210Sym0KindInference) ())
-    type Traverse_0123456789876543210Sym1 :: (~>) a (f b)
-                                             -> (~>) (Empty a) (f (Empty b))
-    data Traverse_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a (f b)) :: (~>) (Empty a) (f (Empty b))
-      where
-        Traverse_0123456789876543210Sym1KindInference :: SameKind (Apply (Traverse_0123456789876543210Sym1 a0123456789876543210) arg) (Traverse_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         Traverse_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Traverse_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Traverse_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Traverse_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Traverse_0123456789876543210Sym1KindInference) ())
-    type Traverse_0123456789876543210Sym2 :: (~>) a (f b)
-                                             -> Empty a -> f (Empty b)
-    type family Traverse_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a (f b)) (a0123456789876543210 :: Empty a) :: f (Empty b) where
-      Traverse_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Traverse_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PTraversable Empty where
-      type Traverse a a = Apply (Apply Traverse_0123456789876543210Sym0 a) a
-    data ST :: forall x a. T x a -> Type
-      where
-        SMkT1 :: forall x
-                        a
-                        (n :: x)
-                        (n :: a)
-                        (n :: Maybe a)
-                        (n :: Maybe (Maybe a)).
-                 (Sing n) ->
-                 (Sing n) ->
-                 (Sing n) ->
-                 (Sing n) ->
-                 ST (MkT1 n n n n :: T x a)
-        SMkT2 :: forall x a (n :: Maybe x).
-                 (Sing n) -> ST (MkT2 n :: T x a)
-    type instance Sing @(T x a) = ST
-    instance (SingKind x, SingKind a) => SingKind (T x a) where
-      type Demote (T x a) = T (Demote x) (Demote a)
-      fromSing (SMkT1 b b b b)
-        = (((MkT1 (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)
-      fromSing (SMkT2 b) = MkT2 (fromSing b)
-      toSing
-        (MkT1 (b :: Demote x) (b :: Demote a) (b :: Demote (Maybe a))
-              (b :: Demote (Maybe (Maybe a))))
-        = case
-              ((((,,,) (toSing b :: SomeSing x)) (toSing b :: SomeSing a))
-                 (toSing b :: SomeSing (Maybe a)))
-                (toSing b :: SomeSing (Maybe (Maybe a)))
-          of
-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
-              -> SomeSing ((((SMkT1 c) c) c) c)
-      toSing (MkT2 (b :: Demote (Maybe x)))
-        = case toSing b :: SomeSing (Maybe x) of
-            SomeSing c -> SomeSing (SMkT2 c)
-    data SEmpty :: forall (a :: Type). Empty a -> Type
-    type instance Sing @(Empty a) = SEmpty
-    instance SingKind a => SingKind (Empty a) where
-      type Demote (Empty a) = Empty (Demote a)
-      fromSing x = case x of {}
-      toSing x = SomeSing (case x of {})
-    instance SFunctor (T x) where
-      sFmap ::
-        forall (a :: Type)
-               (b :: Type)
-               (t1 :: (~>) a b)
-               (t2 :: T x a). Sing t1
-                              -> Sing t2
-                                 -> Sing (Apply (Apply (FmapSym0 :: TyFun ((~>) a b) ((~>) (T x a) (T x b))
-                                                                    -> Type) t1) t2)
-      (%<$) ::
-        forall (a :: Type) (b :: Type) (t1 :: a) (t2 :: T x b). Sing t1
-                                                                -> Sing t2
-                                                                   -> Sing (Apply (Apply ((<$@#@$) :: TyFun a ((~>) (T x b) (T x a))
-                                                                                                      -> Type) t1) t2)
-      sFmap
-        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
-        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing
-                     ((applySing ((singFun4 @MkT1Sym0) SMkT1))
-                        ((applySing
-                            ((singFun1
-                                @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))
-                               (\ sN_0123456789876543210
-                                  -> case sN_0123456789876543210 of
-                                       (_ :: Sing n_0123456789876543210)
-                                         -> sN_0123456789876543210)))
-                           sA_0123456789876543210)))
-                    ((applySing _sf_0123456789876543210) sA_0123456789876543210)))
-                ((applySing
-                    ((applySing ((singFun2 @FmapSym0) sFmap)) _sf_0123456789876543210))
-                   sA_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @FmapSym0) sFmap))
-                   ((applySing ((singFun2 @FmapSym0) sFmap))
-                      _sf_0123456789876543210)))
-               sA_0123456789876543210)
-      sFmap
-        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
-        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        = (applySing ((singFun1 @MkT2Sym0) SMkT2))
-            ((applySing
-                ((singFun1
-                    @(Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210))
-                   (\ sN_0123456789876543210
-                      -> case sN_0123456789876543210 of
-                           (_ :: Sing n_0123456789876543210) -> sN_0123456789876543210)))
-               sA_0123456789876543210)
-      (%<$)
-        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)
-        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing
-                     ((applySing ((singFun4 @MkT1Sym0) SMkT1))
-                        ((applySing
-                            ((singFun1
-                                @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))
-                               (\ sN_0123456789876543210
-                                  -> case sN_0123456789876543210 of
-                                       (_ :: Sing n_0123456789876543210)
-                                         -> sN_0123456789876543210)))
-                           sA_0123456789876543210)))
-                    ((applySing
-                        ((singFun1
-                            @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))
-                           (\ sN_0123456789876543210
-                              -> case sN_0123456789876543210 of
-                                   (_ :: Sing n_0123456789876543210) -> _sz_0123456789876543210)))
-                       sA_0123456789876543210)))
-                ((applySing
-                    ((applySing ((singFun2 @(<$@#@$)) (%<$))) _sz_0123456789876543210))
-                   sA_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @FmapSym0) sFmap))
-                   ((applySing ((singFun2 @(<$@#@$)) (%<$)))
-                      _sz_0123456789876543210)))
-               sA_0123456789876543210)
-      (%<$)
-        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)
-        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        = (applySing ((singFun1 @MkT2Sym0) SMkT2))
-            ((applySing
-                ((singFun1
-                    @(Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210))
-                   (\ sN_0123456789876543210
-                      -> case sN_0123456789876543210 of
-                           (_ :: Sing n_0123456789876543210) -> sN_0123456789876543210)))
-               sA_0123456789876543210)
-    instance SFoldable (T x) where
-      sFoldMap ::
-        forall (a :: Type)
-               (m :: Type)
-               (t1 :: (~>) a m)
-               (t2 :: T x a). SMonoid m =>
-                              Sing t1
-                              -> Sing t2
-                                 -> Sing (Apply (Apply (FoldMapSym0 :: TyFun ((~>) a m) ((~>) (T x a) m)
-                                                                       -> Type) t1) t2)
-      sFoldr ::
-        forall (a :: Type)
-               (b :: Type)
-               (t1 :: (~>) a ((~>) b b))
-               (t2 :: b)
-               (t3 :: T x a). Sing t1
-                              -> Sing t2
-                                 -> Sing t3
-                                    -> Sing (Apply (Apply (Apply (FoldrSym0 :: TyFun ((~>) a ((~>) b b)) ((~>) b ((~>) (T x a) b))
-                                                                               -> Type) t1) t2) t3)
-      sFoldMap
-        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
-        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @MappendSym0) sMappend))
-                ((applySing
-                    ((singFun1
-                        @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))
-                       (\ sN_0123456789876543210
-                          -> case sN_0123456789876543210 of
-                               (_ :: Sing n_0123456789876543210) -> sMempty)))
-                   sA_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @MappendSym0) sMappend))
-                   ((applySing _sf_0123456789876543210) sA_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @MappendSym0) sMappend))
-                      ((applySing
-                          ((applySing ((singFun2 @FoldMapSym0) sFoldMap))
-                             _sf_0123456789876543210))
-                         sA_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @FoldMapSym0) sFoldMap))
-                         ((applySing ((singFun2 @FoldMapSym0) sFoldMap))
-                            _sf_0123456789876543210)))
-                     sA_0123456789876543210)))
-      sFoldMap
-        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
-        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        = (applySing
-             ((singFun1
-                 @(Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210))
-                (\ sN_0123456789876543210
-                   -> case sN_0123456789876543210 of
-                        (_ :: Sing n_0123456789876543210) -> sMempty)))
-            sA_0123456789876543210
-      sFoldr
-        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
-        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)
-        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((singFun2
-                     @(Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))
-                    (\ sN1_0123456789876543210 sN2_0123456789876543210
-                       -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of
-                            (,) (_ :: Sing n1_0123456789876543210)
-                                (_ :: Sing n2_0123456789876543210)
-                              -> sN2_0123456789876543210)))
-                sA_0123456789876543210))
-            ((applySing
-                ((applySing _sf_0123456789876543210) sA_0123456789876543210))
-               ((applySing
-                   ((applySing
-                       ((singFun2
-                           @(Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))
-                          (\ sN1_0123456789876543210 sN2_0123456789876543210
-                             -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of
-                                  (,) (_ :: Sing n1_0123456789876543210)
-                                      (_ :: Sing n2_0123456789876543210)
-                                    -> (applySing
-                                          ((applySing
-                                              ((applySing ((singFun3 @FoldrSym0) sFoldr))
-                                                 _sf_0123456789876543210))
-                                             sN2_0123456789876543210))
-                                         sN1_0123456789876543210)))
-                      sA_0123456789876543210))
-                  ((applySing
-                      ((applySing
-                          ((singFun2
-                              @(Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))
-                             (\ sN1_0123456789876543210 sN2_0123456789876543210
-                                -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of
-                                     (,) (_ :: Sing n1_0123456789876543210)
-                                         (_ :: Sing n2_0123456789876543210)
-                                       -> (applySing
-                                             ((applySing
-                                                 ((applySing ((singFun3 @FoldrSym0) sFoldr))
-                                                    ((singFun2
-                                                        @(Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 n1_0123456789876543210) n2_0123456789876543210) _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))
-                                                       (\ sN1_0123456789876543210
-                                                          sN2_0123456789876543210
-                                                          -> case
-                                                                 ((,) sN1_0123456789876543210)
-                                                                   sN2_0123456789876543210
-                                                             of
-                                                               (,) (_ :: Sing n1_0123456789876543210)
-                                                                   (_ :: Sing n2_0123456789876543210)
-                                                                 -> (applySing
-                                                                       ((applySing
-                                                                           ((applySing
-                                                                               ((singFun3
-                                                                                   @FoldrSym0)
-                                                                                  sFoldr))
-                                                                              _sf_0123456789876543210))
-                                                                          sN2_0123456789876543210))
-                                                                      sN1_0123456789876543210))))
-                                                sN2_0123456789876543210))
-                                            sN1_0123456789876543210)))
-                         sA_0123456789876543210))
-                     _sz_0123456789876543210)))
-      sFoldr
-        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
-        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)
-        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((singFun2
-                     @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210))
-                    (\ sN1_0123456789876543210 sN2_0123456789876543210
-                       -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of
-                            (,) (_ :: Sing n1_0123456789876543210)
-                                (_ :: Sing n2_0123456789876543210)
-                              -> sN2_0123456789876543210)))
-                sA_0123456789876543210))
-            _sz_0123456789876543210
-    instance STraversable (T x) where
-      sTraverse ::
-        forall (a :: Type)
-               (f :: Type -> Type)
-               (b :: Type)
-               (t1 :: (~>) a (f b))
-               (t2 :: T x a). SApplicative f =>
-                              Sing t1
-                              -> Sing t2
-                                 -> Sing (Apply (Apply (TraverseSym0 :: TyFun ((~>) a (f b)) ((~>) (T x a) (f (T x b)))
-                                                                        -> Type) t1) t2)
-      sTraverse
-        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
-        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210)
-               (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(<*>@#@$)) (%<*>)))
-                ((applySing
-                    ((applySing ((singFun2 @(<*>@#@$)) (%<*>)))
-                       ((applySing
-                           ((applySing
-                               ((applySing ((singFun3 @LiftA2Sym0) sLiftA2))
-                                  ((singFun4 @MkT1Sym0) SMkT1)))
-                              ((applySing ((singFun1 @PureSym0) sPure)) sA_0123456789876543210)))
-                          ((applySing _sf_0123456789876543210) sA_0123456789876543210))))
-                   ((applySing
-                       ((applySing ((singFun2 @TraverseSym0) sTraverse))
-                          _sf_0123456789876543210))
-                      sA_0123456789876543210))))
-            ((applySing
-                ((applySing ((singFun2 @TraverseSym0) sTraverse))
-                   ((applySing ((singFun2 @TraverseSym0) sTraverse))
-                      _sf_0123456789876543210)))
-               sA_0123456789876543210)
-      sTraverse
-        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
-        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @FmapSym0) sFmap))
-                ((singFun1 @MkT2Sym0) SMkT2)))
-            ((applySing ((singFun1 @PureSym0) sPure)) sA_0123456789876543210)
-    instance SFunctor Empty where
-      sFmap ::
-        forall (a :: Type)
-               (b :: Type)
-               (t1 :: (~>) a b)
-               (t2 :: Empty a). Sing t1
-                                -> Sing t2
-                                   -> Sing (Apply (Apply (FmapSym0 :: TyFun ((~>) a b) ((~>) (Empty a) (Empty b))
-                                                                      -> Type) t1) t2)
-      (%<$) ::
-        forall (a :: Type) (b :: Type) (t1 :: a) (t2 :: Empty b). Sing t1
-                                                                  -> Sing t2
-                                                                     -> Sing (Apply (Apply ((<$@#@$) :: TyFun a ((~>) (Empty b) (Empty a))
-                                                                                                        -> Type) t1) t2)
-      sFmap _ (sV_0123456789876543210 :: Sing v_0123456789876543210)
-        = (id
-             @(Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)))
-            (case sV_0123456789876543210 of {})
-      (%<$) _ (sV_0123456789876543210 :: Sing v_0123456789876543210)
-        = (id
-             @(Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)))
-            (case sV_0123456789876543210 of {})
-    instance SFoldable Empty where
-      sFoldMap ::
-        forall (a :: Type)
-               (m :: Type)
-               (t1 :: (~>) a m)
-               (t2 :: Empty a). SMonoid m =>
-                                Sing t1
-                                -> Sing t2
-                                   -> Sing (Apply (Apply (FoldMapSym0 :: TyFun ((~>) a m) ((~>) (Empty a) m)
-                                                                         -> Type) t1) t2)
-      sFoldMap _ _ = sMempty
-    instance STraversable Empty where
-      sTraverse ::
-        forall (a :: Type)
-               (f :: Type -> Type)
-               (b :: Type)
-               (t1 :: (~>) a (f b))
-               (t2 :: Empty a). SApplicative f =>
-                                Sing t1
-                                -> Sing t2
-                                   -> Sing (Apply (Apply (TraverseSym0 :: TyFun ((~>) a (f b)) ((~>) (Empty a) (f (Empty b)))
-                                                                          -> Type) t1) t2)
-      sTraverse _ (sV_0123456789876543210 :: Sing v_0123456789876543210)
-        = (applySing ((singFun1 @PureSym0) sPure))
-            ((id
-                @(Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)))
-               (case sV_0123456789876543210 of {}))
-    instance (SingI n, SingI n, SingI n, SingI n) =>
-             SingI (MkT1 (n :: x) (n :: a) (n :: Maybe a) (n :: Maybe (Maybe a))) where
-      sing = (((SMkT1 sing) sing) sing) sing
-    instance (SingI n, SingI n, SingI n) =>
-             SingI1 (MkT1 (n :: x) (n :: a) (n :: Maybe a)) where
-      liftSing = ((SMkT1 sing) sing) sing
-    instance (SingI n, SingI n) =>
-             SingI2 (MkT1 (n :: x) (n :: a)) where
-      liftSing2 = (SMkT1 sing) sing
-    instance SingI (MkT1Sym0 :: (~>) x ((~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))))) where
-      sing = (singFun4 @MkT1Sym0) SMkT1
-    instance SingI d =>
-             SingI (MkT1Sym1 (d :: x) :: (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) where
-      sing = (singFun3 @(MkT1Sym1 (d :: x))) (SMkT1 (sing @d))
-    instance SingI1 (MkT1Sym1 :: x
-                                 -> (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) where
-      liftSing (s :: Sing (d :: x))
-        = (singFun3 @(MkT1Sym1 (d :: x))) (SMkT1 s)
-    instance (SingI d, SingI d) =>
-             SingI (MkT1Sym2 (d :: x) (d :: a) :: (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where
-      sing
-        = (singFun2 @(MkT1Sym2 (d :: x) (d :: a)))
-            ((SMkT1 (sing @d)) (sing @d))
-    instance SingI d =>
-             SingI1 (MkT1Sym2 (d :: x) :: a
-                                          -> (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where
-      liftSing (s :: Sing (d :: a))
-        = (singFun2 @(MkT1Sym2 (d :: x) (d :: a))) ((SMkT1 (sing @d)) s)
-    instance SingI2 (MkT1Sym2 :: x
-                                 -> a -> (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where
-      liftSing2 (s :: Sing (d :: x)) (s :: Sing (d :: a))
-        = (singFun2 @(MkT1Sym2 (d :: x) (d :: a))) ((SMkT1 s) s)
-    instance (SingI d, SingI d, SingI d) =>
-             SingI (MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a) :: (~>) (Maybe (Maybe a)) (T x a)) where
-      sing
-        = (singFun1 @(MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a)))
-            (((SMkT1 (sing @d)) (sing @d)) (sing @d))
-    instance (SingI d, SingI d) =>
-             SingI1 (MkT1Sym3 (d :: x) (d :: a) :: Maybe a
-                                                   -> (~>) (Maybe (Maybe a)) (T x a)) where
-      liftSing (s :: Sing (d :: Maybe a))
-        = (singFun1 @(MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a)))
-            (((SMkT1 (sing @d)) (sing @d)) s)
-    instance SingI d =>
-             SingI2 (MkT1Sym3 (d :: x) :: a
-                                          -> Maybe a -> (~>) (Maybe (Maybe a)) (T x a)) where
-      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: Maybe a))
-        = (singFun1 @(MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a)))
-            (((SMkT1 (sing @d)) s) s)
-    instance SingI n => SingI (MkT2 (n :: Maybe x)) where
-      sing = SMkT2 sing
-    instance SingI1 MkT2 where
-      liftSing = SMkT2
-    instance SingI (MkT2Sym0 :: (~>) (Maybe x) (T x a)) where
-      sing = (singFun1 @MkT2Sym0) SMkT2
+    type instance Apply @x @((~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) MkT1Sym0 a0123456789876543210 = MkT1Sym1 a0123456789876543210
+    instance SuppressUnusedWarnings MkT1Sym0 where
+      suppressUnusedWarnings = snd ((,) MkT1Sym0KindInference ())
+    type MkT1Sym1 :: forall x a. x
+                                 -> (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))
+    data MkT1Sym1 (a0123456789876543210 :: x) :: (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))
+      where
+        MkT1Sym1KindInference :: SameKind (Apply (MkT1Sym1 a0123456789876543210) arg) (MkT1Sym2 a0123456789876543210 arg) =>
+                                 MkT1Sym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @a @((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) (MkT1Sym1 a0123456789876543210) a0123456789876543210 = MkT1Sym2 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (MkT1Sym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) MkT1Sym1KindInference ())
+    type MkT1Sym2 :: forall x a. x
+                                 -> a -> (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))
+    data MkT1Sym2 (a0123456789876543210 :: x) (a0123456789876543210 :: a) :: (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))
+      where
+        MkT1Sym2KindInference :: SameKind (Apply (MkT1Sym2 a0123456789876543210 a0123456789876543210) arg) (MkT1Sym3 a0123456789876543210 a0123456789876543210 arg) =>
+                                 MkT1Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @(Maybe a) @((~>) (Maybe (Maybe a)) (T x a)) (MkT1Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (MkT1Sym2 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) MkT1Sym2KindInference ())
+    type MkT1Sym3 :: forall x a. x
+                                 -> a -> Maybe a -> (~>) (Maybe (Maybe a)) (T x a)
+    data MkT1Sym3 (a0123456789876543210 :: x) (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) :: (~>) (Maybe (Maybe a)) (T x a)
+      where
+        MkT1Sym3KindInference :: SameKind (Apply (MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (MkT1Sym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
+                                 MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @(Maybe (Maybe a)) @(T x a) (MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = MkT1 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) MkT1Sym3KindInference ())
+    type MkT1Sym4 :: forall x a. x
+                                 -> a -> Maybe a -> Maybe (Maybe a) -> T x a
+    type family MkT1Sym4 @x @a (a0123456789876543210 :: x) (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) (a0123456789876543210 :: Maybe (Maybe a)) :: T x a where
+      MkT1Sym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = MkT1 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type MkT2Sym0 :: forall x a. (~>) (Maybe x) (T x a)
+    data MkT2Sym0 :: (~>) (Maybe x) (T x a)
+      where
+        MkT2Sym0KindInference :: SameKind (Apply MkT2Sym0 arg) (MkT2Sym1 arg) =>
+                                 MkT2Sym0 a0123456789876543210
+    type instance Apply @(Maybe x) @(T x a) MkT2Sym0 a0123456789876543210 = MkT2 a0123456789876543210
+    instance SuppressUnusedWarnings MkT2Sym0 where
+      suppressUnusedWarnings = snd ((,) MkT2Sym0KindInference ())
+    type MkT2Sym1 :: forall x a. Maybe x -> T x a
+    type family MkT2Sym1 @x @a (a0123456789876543210 :: Maybe x) :: T x a where
+      MkT2Sym1 a0123456789876543210 = MkT2 a0123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x _f_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type Fmap_0123456789876543210 :: forall x a b. (~>) a b
+                                                   -> T x a -> T x b
+    type family Fmap_0123456789876543210 @x @a @b (a :: (~>) a b) (a :: T x a) :: T x b where
+      Fmap_0123456789876543210 @x @a @b (_f_0123456789876543210 :: (~>) a b) (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: T x a) = Apply (Apply (Apply (Apply MkT1Sym0 (Apply (LamCases_0123456789876543210Sym0 x _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210)) (Apply _f_0123456789876543210 a_0123456789876543210)) (Apply (Apply FmapSym0 _f_0123456789876543210) a_0123456789876543210)) (Apply (Apply FmapSym0 (Apply FmapSym0 _f_0123456789876543210)) a_0123456789876543210)
+      Fmap_0123456789876543210 @x @a @b (_f_0123456789876543210 :: (~>) a b) (MkT2 a_0123456789876543210 :: T x a) = Apply MkT2Sym0 (Apply (LamCases_0123456789876543210Sym0 x _f_0123456789876543210 a_0123456789876543210) a_0123456789876543210)
+    type family LamCases_0123456789876543210 x0123456789876543210 (_z_01234567898765432100123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (_z_01234567898765432100123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 (_z_01234567898765432100123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 (_z_01234567898765432100123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 _ = _z_0123456789876543210
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (_z_01234567898765432100123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 (_z_01234567898765432100123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 (_z_01234567898765432100123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x _z_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (_z_01234567898765432100123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 (_z_01234567898765432100123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type TFHelper_0123456789876543210 :: forall x a b. a
+                                                       -> T x b -> T x a
+    type family TFHelper_0123456789876543210 @x @a @b (a :: a) (a :: T x b) :: T x a where
+      TFHelper_0123456789876543210 @x @a @b (_z_0123456789876543210 :: a) (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: T x b) = Apply (Apply (Apply (Apply MkT1Sym0 (Apply (LamCases_0123456789876543210Sym0 x _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210)) (Apply (LamCases_0123456789876543210Sym0 x _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210)) (Apply (Apply (<$@#@$) _z_0123456789876543210) a_0123456789876543210)) (Apply (Apply FmapSym0 (Apply (<$@#@$) _z_0123456789876543210)) a_0123456789876543210)
+      TFHelper_0123456789876543210 @x @a @b (_z_0123456789876543210 :: a) (MkT2 a_0123456789876543210 :: T x b) = Apply MkT2Sym0 (Apply (LamCases_0123456789876543210Sym0 x _z_0123456789876543210 a_0123456789876543210) a_0123456789876543210)
+    instance PFunctor (T x) where
+      type Fmap a a = Fmap_0123456789876543210 a a
+      type (<$) a a = TFHelper_0123456789876543210 a a
+    type family LamCases_0123456789876543210 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 _ = MemptySym0
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) a_01234567898765432100123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x _f_0123456789876543210 a_0123456789876543210 _ = MemptySym0
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type FoldMap_0123456789876543210 :: forall x a m. (~>) a m
+                                                      -> T x a -> m
+    type family FoldMap_0123456789876543210 @x @a @m (a :: (~>) a m) (a :: T x a) :: m where
+      FoldMap_0123456789876543210 @x @a @m (_f_0123456789876543210 :: (~>) a m) (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: T x a) = Apply (Apply MappendSym0 (Apply (LamCases_0123456789876543210Sym0 x _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210)) (Apply (Apply MappendSym0 (Apply _f_0123456789876543210 a_0123456789876543210)) (Apply (Apply MappendSym0 (Apply (Apply FoldMapSym0 _f_0123456789876543210) a_0123456789876543210)) (Apply (Apply FoldMapSym0 (Apply FoldMapSym0 _f_0123456789876543210)) a_0123456789876543210)))
+      FoldMap_0123456789876543210 @x @a @m (_f_0123456789876543210 :: (~>) a m) (MkT2 a_0123456789876543210 :: T x a) = Apply (LamCases_0123456789876543210Sym0 x _f_0123456789876543210 a_0123456789876543210) a_0123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 _ n_0123456789876543210 = n_0123456789876543210
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    data LamCases_0123456789876543210Sym1 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym1KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym2 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym1KindInference ())
+    type family LamCases_0123456789876543210Sym2 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym2 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = Apply (Apply (Apply FoldrSym0 _f_0123456789876543210) n2_0123456789876543210) n1_0123456789876543210
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    data LamCases_0123456789876543210Sym1 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym1KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym2 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym1KindInference ())
+    type family LamCases_0123456789876543210Sym2 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym2 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x n1_0123456789876543210 n2_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = Apply (Apply (Apply FoldrSym0 _f_0123456789876543210) n2_0123456789876543210) n1_0123456789876543210
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210Sym1 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    data LamCases_0123456789876543210Sym1 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym1KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym1 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym2 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym1 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym1 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym1 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym1KindInference ())
+    type family LamCases_0123456789876543210Sym2 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym2 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = Apply (Apply (Apply FoldrSym0 (LamCases_0123456789876543210Sym0 x n1_0123456789876543210 n2_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210)) n2_0123456789876543210) n1_0123456789876543210
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    data LamCases_0123456789876543210Sym1 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym1KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym2 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym1KindInference ())
+    type family LamCases_0123456789876543210Sym2 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym2 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 _ n_0123456789876543210 = n_0123456789876543210
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    data LamCases_0123456789876543210Sym1 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym1KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym2 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym1 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym1KindInference ())
+    type family LamCases_0123456789876543210Sym2 x0123456789876543210 (_f_01234567898765432100123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (_z_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym2 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type Foldr_0123456789876543210 :: forall x a b. (~>) a ((~>) b b)
+                                                    -> b -> T x a -> b
+    type family Foldr_0123456789876543210 @x @a @b (a :: (~>) a ((~>) b b)) (a :: b) (a :: T x a) :: b where
+      Foldr_0123456789876543210 @x @a @b (_f_0123456789876543210 :: (~>) a ((~>) b b)) (_z_0123456789876543210 :: b) (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: T x a) = Apply (Apply (LamCases_0123456789876543210Sym0 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210) (Apply (Apply _f_0123456789876543210 a_0123456789876543210) (Apply (Apply (LamCases_0123456789876543210Sym0 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210) (Apply (Apply (LamCases_0123456789876543210Sym0 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210) _z_0123456789876543210)))
+      Foldr_0123456789876543210 @x @a @b (_f_0123456789876543210 :: (~>) a ((~>) b b)) (_z_0123456789876543210 :: b) (MkT2 a_0123456789876543210 :: T x a) = Apply (Apply (LamCases_0123456789876543210Sym0 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210) a_0123456789876543210) _z_0123456789876543210
+    instance PFoldable (T x) where
+      type FoldMap a a = FoldMap_0123456789876543210 a a
+      type Foldr a a a = Foldr_0123456789876543210 a a a
+    type Traverse_0123456789876543210 :: forall x a f b. (~>) a (f b)
+                                                         -> T x a -> f (T x b)
+    type family Traverse_0123456789876543210 @x @a @f @b (a :: (~>) a (f b)) (a :: T x a) :: f (T x b) where
+      Traverse_0123456789876543210 @x @a @f @b (_f_0123456789876543210 :: (~>) a (f b)) (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: T x a) = Apply (Apply (<*>@#@$) (Apply (Apply (<*>@#@$) (Apply (Apply (Apply LiftA2Sym0 MkT1Sym0) (Apply PureSym0 a_0123456789876543210)) (Apply _f_0123456789876543210 a_0123456789876543210))) (Apply (Apply TraverseSym0 _f_0123456789876543210) a_0123456789876543210))) (Apply (Apply TraverseSym0 (Apply TraverseSym0 _f_0123456789876543210)) a_0123456789876543210)
+      Traverse_0123456789876543210 @x @a @f @b (_f_0123456789876543210 :: (~>) a (f b)) (MkT2 a_0123456789876543210 :: T x a) = Apply (Apply FmapSym0 MkT2Sym0) (Apply PureSym0 a_0123456789876543210)
+    instance PTraversable (T x) where
+      type Traverse a a = Traverse_0123456789876543210 a a
+    type family LamCases_0123456789876543210 (v_01234567898765432100123456789876543210 :: Empty a0123456789876543210) a_0123456789876543210 where
+    data LamCases_0123456789876543210Sym0 (v_01234567898765432100123456789876543210 :: Empty a0123456789876543210) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 v_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (v_01234567898765432100123456789876543210 :: Empty a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type Fmap_0123456789876543210 :: forall a b. (~>) a b
+                                                 -> Empty a -> Empty b
+    type family Fmap_0123456789876543210 @a @b (a :: (~>) a b) (a :: Empty a) :: Empty b where
+      Fmap_0123456789876543210 @a @b _ v_0123456789876543210 = Apply (LamCases_0123456789876543210Sym0 v_0123456789876543210) v_0123456789876543210
+    type family LamCases_0123456789876543210 (v_01234567898765432100123456789876543210 :: Empty b0123456789876543210) a_0123456789876543210 where
+    data LamCases_0123456789876543210Sym0 (v_01234567898765432100123456789876543210 :: Empty b0123456789876543210) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 v_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (v_01234567898765432100123456789876543210 :: Empty b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type TFHelper_0123456789876543210 :: forall a b. a
+                                                     -> Empty b -> Empty a
+    type family TFHelper_0123456789876543210 @a @b (a :: a) (a :: Empty b) :: Empty a where
+      TFHelper_0123456789876543210 @a @b _ v_0123456789876543210 = Apply (LamCases_0123456789876543210Sym0 v_0123456789876543210) v_0123456789876543210
+    instance PFunctor Empty where
+      type Fmap a a = Fmap_0123456789876543210 a a
+      type (<$) a a = TFHelper_0123456789876543210 a a
+    type FoldMap_0123456789876543210 :: forall a m. (~>) a m
+                                                    -> Empty a -> m
+    type family FoldMap_0123456789876543210 @a @m (a :: (~>) a m) (a :: Empty a) :: m where
+      FoldMap_0123456789876543210 @a @m _ _ = MemptySym0
+    instance PFoldable Empty where
+      type FoldMap a a = FoldMap_0123456789876543210 a a
+    type family LamCases_0123456789876543210 (v_01234567898765432100123456789876543210 :: Empty a0123456789876543210) a_0123456789876543210 where
+    data LamCases_0123456789876543210Sym0 (v_01234567898765432100123456789876543210 :: Empty a0123456789876543210) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 v_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (v_01234567898765432100123456789876543210 :: Empty a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type Traverse_0123456789876543210 :: forall a f b. (~>) a (f b)
+                                                       -> Empty a -> f (Empty b)
+    type family Traverse_0123456789876543210 @a @f @b (a :: (~>) a (f b)) (a :: Empty a) :: f (Empty b) where
+      Traverse_0123456789876543210 @a @f @b _ v_0123456789876543210 = Apply PureSym0 (Apply (LamCases_0123456789876543210Sym0 v_0123456789876543210) v_0123456789876543210)
+    instance PTraversable Empty where
+      type Traverse a a = Traverse_0123456789876543210 a a
+    data ST :: forall x a. T x a -> Type
+      where
+        SMkT1 :: forall x
+                        a
+                        (n :: x)
+                        (n :: a)
+                        (n :: Maybe a)
+                        (n :: Maybe (Maybe a)).
+                 (Sing n) ->
+                 (Sing n) ->
+                 (Sing n) ->
+                 (Sing n) ->
+                 ST (MkT1 n n n n :: T x a)
+        SMkT2 :: forall x a (n :: Maybe x).
+                 (Sing n) -> ST (MkT2 n :: T x a)
+    type instance Sing @(T x a) = ST
+    instance (SingKind x, SingKind a) => SingKind (T x a) where
+      type Demote (T x a) = T (Demote x) (Demote a)
+      fromSing (SMkT1 b b b b)
+        = MkT1 (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      fromSing (SMkT2 b) = MkT2 (fromSing b)
+      toSing
+        (MkT1 (b :: Demote x) (b :: Demote a) (b :: Demote (Maybe a))
+              (b :: Demote (Maybe (Maybe a))))
+        = (\cases
+             (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+               -> SomeSing (SMkT1 c c c c))
+            (toSing b :: SomeSing x) (toSing b :: SomeSing a)
+            (toSing b :: SomeSing (Maybe a))
+            (toSing b :: SomeSing (Maybe (Maybe a)))
+      toSing (MkT2 (b :: Demote (Maybe x)))
+        = (\cases (SomeSing c) -> SomeSing (SMkT2 c))
+            (toSing b :: SomeSing (Maybe x))
+    data SEmpty :: forall (a :: Type). Empty a -> Type
+    type instance Sing @(Empty a) = SEmpty
+    instance SingKind a => SingKind (Empty a) where
+      type Demote (Empty a) = Empty (Demote a)
+      fromSing x = (\case) x
+      toSing x = SomeSing ((\case) x)
+    instance SFunctor (T x) where
+      sFmap
+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
+        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        = applySing
+            (applySing
+               (applySing
+                  (applySing
+                     (singFun4 @MkT1Sym0 SMkT1)
+                     (applySing
+                        (singFun1
+                           @(LamCases_0123456789876543210Sym0 x _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210)
+                           (\cases
+                              (sN_0123456789876543210 :: Sing n_0123456789876543210)
+                                -> sN_0123456789876543210))
+                        sA_0123456789876543210))
+                  (applySing _sf_0123456789876543210 sA_0123456789876543210))
+               (applySing
+                  (applySing (singFun2 @FmapSym0 sFmap) _sf_0123456789876543210)
+                  sA_0123456789876543210))
+            (applySing
+               (applySing
+                  (singFun2 @FmapSym0 sFmap)
+                  (applySing (singFun2 @FmapSym0 sFmap) _sf_0123456789876543210))
+               sA_0123456789876543210)
+      sFmap
+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
+        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        = applySing
+            (singFun1 @MkT2Sym0 SMkT2)
+            (applySing
+               (singFun1
+                  @(LamCases_0123456789876543210Sym0 x _f_0123456789876543210 a_0123456789876543210)
+                  (\cases
+                     (sN_0123456789876543210 :: Sing n_0123456789876543210)
+                       -> sN_0123456789876543210))
+               sA_0123456789876543210)
+      (%<$)
+        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)
+        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        = applySing
+            (applySing
+               (applySing
+                  (applySing
+                     (singFun4 @MkT1Sym0 SMkT1)
+                     (applySing
+                        (singFun1
+                           @(LamCases_0123456789876543210Sym0 x _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210)
+                           (\cases
+                              (sN_0123456789876543210 :: Sing n_0123456789876543210)
+                                -> sN_0123456789876543210))
+                        sA_0123456789876543210))
+                  (applySing
+                     (singFun1
+                        @(LamCases_0123456789876543210Sym0 x _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210)
+                        (\cases _ -> _sz_0123456789876543210))
+                     sA_0123456789876543210))
+               (applySing
+                  (applySing (singFun2 @(<$@#@$) (%<$)) _sz_0123456789876543210)
+                  sA_0123456789876543210))
+            (applySing
+               (applySing
+                  (singFun2 @FmapSym0 sFmap)
+                  (applySing (singFun2 @(<$@#@$) (%<$)) _sz_0123456789876543210))
+               sA_0123456789876543210)
+      (%<$)
+        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)
+        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        = applySing
+            (singFun1 @MkT2Sym0 SMkT2)
+            (applySing
+               (singFun1
+                  @(LamCases_0123456789876543210Sym0 x _z_0123456789876543210 a_0123456789876543210)
+                  (\cases
+                     (sN_0123456789876543210 :: Sing n_0123456789876543210)
+                       -> sN_0123456789876543210))
+               sA_0123456789876543210)
+    instance SFoldable (T x) where
+      sFoldMap
+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
+        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @MappendSym0 sMappend)
+               (applySing
+                  (singFun1
+                     @(LamCases_0123456789876543210Sym0 x _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210)
+                     (\cases _ -> sMempty))
+                  sA_0123456789876543210))
+            (applySing
+               (applySing
+                  (singFun2 @MappendSym0 sMappend)
+                  (applySing _sf_0123456789876543210 sA_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @MappendSym0 sMappend)
+                     (applySing
+                        (applySing
+                           (singFun2 @FoldMapSym0 sFoldMap) _sf_0123456789876543210)
+                        sA_0123456789876543210))
+                  (applySing
+                     (applySing
+                        (singFun2 @FoldMapSym0 sFoldMap)
+                        (applySing
+                           (singFun2 @FoldMapSym0 sFoldMap) _sf_0123456789876543210))
+                     sA_0123456789876543210)))
+      sFoldMap
+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
+        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        = applySing
+            (singFun1
+               @(LamCases_0123456789876543210Sym0 x _f_0123456789876543210 a_0123456789876543210)
+               (\cases _ -> sMempty))
+            sA_0123456789876543210
+      sFoldr
+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
+        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)
+        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2
+                  @(LamCases_0123456789876543210Sym0 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210)
+                  (\cases
+                     _ (sN_0123456789876543210 :: Sing n_0123456789876543210)
+                       -> sN_0123456789876543210))
+               sA_0123456789876543210)
+            (applySing
+               (applySing _sf_0123456789876543210 sA_0123456789876543210)
+               (applySing
+                  (applySing
+                     (singFun2
+                        @(LamCases_0123456789876543210Sym0 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210)
+                        (\cases
+                           (sN1_0123456789876543210 :: Sing n1_0123456789876543210)
+                             (sN2_0123456789876543210 :: Sing n2_0123456789876543210)
+                             -> applySing
+                                  (applySing
+                                     (applySing
+                                        (singFun3 @FoldrSym0 sFoldr) _sf_0123456789876543210)
+                                     sN2_0123456789876543210)
+                                  sN1_0123456789876543210))
+                     sA_0123456789876543210)
+                  (applySing
+                     (applySing
+                        (singFun2
+                           @(LamCases_0123456789876543210Sym0 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210)
+                           (\cases
+                              (sN1_0123456789876543210 :: Sing n1_0123456789876543210)
+                                (sN2_0123456789876543210 :: Sing n2_0123456789876543210)
+                                -> applySing
+                                     (applySing
+                                        (applySing
+                                           (singFun3 @FoldrSym0 sFoldr)
+                                           (singFun2
+                                              @(LamCases_0123456789876543210Sym0 x n1_0123456789876543210 n2_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210)
+                                              (\cases
+                                                 (sN1_0123456789876543210 :: Sing n1_0123456789876543210)
+                                                   (sN2_0123456789876543210 :: Sing n2_0123456789876543210)
+                                                   -> applySing
+                                                        (applySing
+                                                           (applySing
+                                                              (singFun3 @FoldrSym0 sFoldr)
+                                                              _sf_0123456789876543210)
+                                                           sN2_0123456789876543210)
+                                                        sN1_0123456789876543210)))
+                                        sN2_0123456789876543210)
+                                     sN1_0123456789876543210))
+                        sA_0123456789876543210)
+                     _sz_0123456789876543210)))
+      sFoldr
+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
+        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)
+        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2
+                  @(LamCases_0123456789876543210Sym0 x _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210)
+                  (\cases
+                     _ (sN_0123456789876543210 :: Sing n_0123456789876543210)
+                       -> sN_0123456789876543210))
+               sA_0123456789876543210)
+            _sz_0123456789876543210
+    instance STraversable (T x) where
+      sTraverse
+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
+        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210)
+               (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @(<*>@#@$) (%<*>))
+               (applySing
+                  (applySing
+                     (singFun2 @(<*>@#@$) (%<*>))
+                     (applySing
+                        (applySing
+                           (applySing
+                              (singFun3 @LiftA2Sym0 sLiftA2) (singFun4 @MkT1Sym0 SMkT1))
+                           (applySing (singFun1 @PureSym0 sPure) sA_0123456789876543210))
+                        (applySing _sf_0123456789876543210 sA_0123456789876543210)))
+                  (applySing
+                     (applySing
+                        (singFun2 @TraverseSym0 sTraverse) _sf_0123456789876543210)
+                     sA_0123456789876543210)))
+            (applySing
+               (applySing
+                  (singFun2 @TraverseSym0 sTraverse)
+                  (applySing
+                     (singFun2 @TraverseSym0 sTraverse) _sf_0123456789876543210))
+               sA_0123456789876543210)
+      sTraverse
+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)
+        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        = applySing
+            (applySing (singFun2 @FmapSym0 sFmap) (singFun1 @MkT2Sym0 SMkT2))
+            (applySing (singFun1 @PureSym0 sPure) sA_0123456789876543210)
+    instance SFunctor Empty where
+      sFmap _ (sV_0123456789876543210 :: Sing v_0123456789876543210)
+        = applySing
+            (singFun1
+               @(LamCases_0123456789876543210Sym0 v_0123456789876543210) (\case))
+            sV_0123456789876543210
+      (%<$) _ (sV_0123456789876543210 :: Sing v_0123456789876543210)
+        = applySing
+            (singFun1
+               @(LamCases_0123456789876543210Sym0 v_0123456789876543210) (\case))
+            sV_0123456789876543210
+    instance SFoldable Empty where
+      sFoldMap _ _ = sMempty
+    instance STraversable Empty where
+      sTraverse _ (sV_0123456789876543210 :: Sing v_0123456789876543210)
+        = applySing
+            (singFun1 @PureSym0 sPure)
+            (applySing
+               (singFun1
+                  @(LamCases_0123456789876543210Sym0 v_0123456789876543210) (\case))
+               sV_0123456789876543210)
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (MkT1 (n :: x) (n :: a) (n :: Maybe a) (n :: Maybe (Maybe a))) where
+      sing = SMkT1 sing sing sing sing
+    instance (SingI n, SingI n, SingI n) =>
+             SingI1 (MkT1 (n :: x) (n :: a) (n :: Maybe a)) where
+      liftSing = SMkT1 sing sing sing
+    instance (SingI n, SingI n) =>
+             SingI2 (MkT1 (n :: x) (n :: a)) where
+      liftSing2 = SMkT1 sing sing
+    instance SingI (MkT1Sym0 :: (~>) x ((~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))))) where
+      sing = singFun4 @MkT1Sym0 SMkT1
+    instance SingI d =>
+             SingI (MkT1Sym1 (d :: x) :: (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) where
+      sing = singFun3 @(MkT1Sym1 (d :: x)) (SMkT1 (sing @d))
+    instance SingI1 (MkT1Sym1 :: x
+                                 -> (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) where
+      liftSing (s :: Sing (d :: x))
+        = singFun3 @(MkT1Sym1 (d :: x)) (SMkT1 s)
+    instance (SingI d, SingI d) =>
+             SingI (MkT1Sym2 (d :: x) (d :: a) :: (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where
+      sing
+        = singFun2
+            @(MkT1Sym2 (d :: x) (d :: a)) (SMkT1 (sing @d) (sing @d))
+    instance SingI d =>
+             SingI1 (MkT1Sym2 (d :: x) :: a
+                                          -> (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where
+      liftSing (s :: Sing (d :: a))
+        = singFun2 @(MkT1Sym2 (d :: x) (d :: a)) (SMkT1 (sing @d) s)
+    instance SingI2 (MkT1Sym2 :: x
+                                 -> a -> (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where
+      liftSing2 (s :: Sing (d :: x)) (s :: Sing (d :: a))
+        = singFun2 @(MkT1Sym2 (d :: x) (d :: a)) (SMkT1 s s)
+    instance (SingI d, SingI d, SingI d) =>
+             SingI (MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a) :: (~>) (Maybe (Maybe a)) (T x a)) where
+      sing
+        = singFun1
+            @(MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a))
+            (SMkT1 (sing @d) (sing @d) (sing @d))
+    instance (SingI d, SingI d) =>
+             SingI1 (MkT1Sym3 (d :: x) (d :: a) :: Maybe a
+                                                   -> (~>) (Maybe (Maybe a)) (T x a)) where
+      liftSing (s :: Sing (d :: Maybe a))
+        = singFun1
+            @(MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a))
+            (SMkT1 (sing @d) (sing @d) s)
+    instance SingI d =>
+             SingI2 (MkT1Sym3 (d :: x) :: a
+                                          -> Maybe a -> (~>) (Maybe (Maybe a)) (T x a)) where
+      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: Maybe a))
+        = singFun1
+            @(MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a)) (SMkT1 (sing @d) s s)
+    instance SingI n => SingI (MkT2 (n :: Maybe x)) where
+      sing = SMkT2 sing
+    instance SingI1 MkT2 where
+      liftSing = SMkT2
+    instance SingI (MkT2Sym0 :: (~>) (Maybe x) (T x a)) where
+      sing = singFun1 @MkT2Sym0 SMkT2
diff --git a/tests/compile-and-dump/Singletons/HigherOrder.golden b/tests/compile-and-dump/Singletons/HigherOrder.golden
--- a/tests/compile-and-dump/Singletons/HigherOrder.golden
+++ b/tests/compile-and-dump/Singletons/HigherOrder.golden
@@ -24,20 +24,20 @@
     data Either a b = Left a | Right b
     map :: (a -> b) -> [a] -> [b]
     map _ [] = []
-    map f (h : t) = (f h : (map f) t)
+    map f (h : t) = (f h : map f t)
     liftMaybe :: (a -> b) -> Maybe a -> Maybe b
     liftMaybe f (Just x) = Just (f x)
     liftMaybe _ Nothing = Nothing
     zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
-    zipWith f (x : xs) (y : ys) = ((f x) y : ((zipWith f) xs) ys)
+    zipWith f (x : xs) (y : ys) = (f x y : zipWith f xs ys)
     zipWith _ [] [] = []
     zipWith _ (_ : _) [] = []
     zipWith _ [] (_ : _) = []
     foo :: ((a -> b) -> a -> b) -> (a -> b) -> a -> b
-    foo f g a = (f g) a
+    foo f g a = f g a
     splunge :: [Nat] -> [Bool] -> [Nat]
     splunge ns bs
-      = ((zipWith (\ n b -> if b then Succ (Succ n) else n)) ns) bs
+      = zipWith (\ n b -> if b then Succ (Succ n) else n) ns bs
     etad :: [Nat] -> [Bool] -> [Nat]
     etad = zipWith (\ n b -> if b then Succ (Succ n) else n)
     type LeftSym0 :: forall a b. (~>) a (Either a b)
@@ -45,117 +45,105 @@
       where
         LeftSym0KindInference :: SameKind (Apply LeftSym0 arg) (LeftSym1 arg) =>
                                  LeftSym0 a0123456789876543210
-    type instance Apply LeftSym0 a0123456789876543210 = Left a0123456789876543210
+    type instance Apply @a @(Either a b) LeftSym0 a0123456789876543210 = Left a0123456789876543210
     instance SuppressUnusedWarnings LeftSym0 where
-      suppressUnusedWarnings = snd (((,) LeftSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) LeftSym0KindInference ())
     type LeftSym1 :: forall a b. a -> Either a b
-    type family LeftSym1 (a0123456789876543210 :: a) :: Either a b where
+    type family LeftSym1 @a @b (a0123456789876543210 :: a) :: Either a b where
       LeftSym1 a0123456789876543210 = Left a0123456789876543210
     type RightSym0 :: forall a b. (~>) b (Either a b)
     data RightSym0 :: (~>) b (Either a b)
       where
         RightSym0KindInference :: SameKind (Apply RightSym0 arg) (RightSym1 arg) =>
                                   RightSym0 a0123456789876543210
-    type instance Apply RightSym0 a0123456789876543210 = Right a0123456789876543210
+    type instance Apply @b @(Either a b) RightSym0 a0123456789876543210 = Right a0123456789876543210
     instance SuppressUnusedWarnings RightSym0 where
-      suppressUnusedWarnings = snd (((,) RightSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) RightSym0KindInference ())
     type RightSym1 :: forall a b. b -> Either a b
-    type family RightSym1 (a0123456789876543210 :: b) :: Either a b where
+    type family RightSym1 @a @b (a0123456789876543210 :: b) :: Either a b where
       RightSym1 a0123456789876543210 = Right a0123456789876543210
-    type family Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 t where
-      Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 'True = Apply SuccSym0 (Apply SuccSym0 n)
-      Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 'False = n
-    type family Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n b where
-      Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n b = Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 b
-    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210
+    type family LamCases_0123456789876543210 n0123456789876543210 b0123456789876543210 (a_01234567898765432100123456789876543210 :: [Nat]) (a_01234567898765432100123456789876543210 :: [Bool]) a_0123456789876543210 where
+      LamCases_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 'True = Apply SuccSym0 (Apply SuccSym0 n)
+      LamCases_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 'False = n
+    data LamCases_0123456789876543210Sym0 n0123456789876543210 b0123456789876543210 (a_01234567898765432100123456789876543210 :: [Nat]) (a_01234567898765432100123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n0123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210 b0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 n0123456789876543210 b0123456789876543210 (a_01234567898765432100123456789876543210 :: [Nat]) (a_01234567898765432100123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (a_01234567898765432100123456789876543210 :: [Nat]) (a_01234567898765432100123456789876543210 :: [Bool]) a_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n b = Apply (LamCases_0123456789876543210Sym0 n b a_0123456789876543210 a_0123456789876543210) b
+    data LamCases_0123456789876543210Sym0 (a_01234567898765432100123456789876543210 :: [Nat]) (a_01234567898765432100123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210) arg) (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210 b0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210) b0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210 b0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    type family Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210 b0123456789876543210 where
-      Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210 b0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n0123456789876543210 b0123456789876543210
-    type family Case_0123456789876543210 n b ns bs t where
-      Case_0123456789876543210 n b ns bs 'True = Apply SuccSym0 (Apply SuccSym0 n)
-      Case_0123456789876543210 n b ns bs 'False = n
-    type family Lambda_0123456789876543210 ns bs n b where
-      Lambda_0123456789876543210 ns bs n b = Case_0123456789876543210 n b ns bs b
-    data Lambda_0123456789876543210Sym0 ns0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    data LamCases_0123456789876543210Sym1 (a_01234567898765432100123456789876543210 :: [Nat]) (a_01234567898765432100123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 ns0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 ns0123456789876543210 = Lambda_0123456789876543210Sym1 ns0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym1KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 ns0123456789876543210 bs0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym1KindInference ())
+    type family LamCases_0123456789876543210Sym2 (a_01234567898765432100123456789876543210 :: [Nat]) (a_01234567898765432100123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 n0123456789876543210 b0123456789876543210 (ns0123456789876543210 :: [Nat]) (bs0123456789876543210 :: [Bool]) a_0123456789876543210 where
+      LamCases_0123456789876543210 n b ns bs 'True = Apply SuccSym0 (Apply SuccSym0 n)
+      LamCases_0123456789876543210 n b ns bs 'False = n
+    data LamCases_0123456789876543210Sym0 n0123456789876543210 b0123456789876543210 (ns0123456789876543210 :: [Nat]) (bs0123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 ns0123456789876543210) arg) (Lambda_0123456789876543210Sym2 ns0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 ns0123456789876543210 bs0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 ns0123456789876543210) bs0123456789876543210 = Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 ns0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210 b0123456789876543210 ns0123456789876543210 bs0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 b0123456789876543210 ns0123456789876543210 bs0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 b0123456789876543210 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210 b0123456789876543210 ns0123456789876543210 bs0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 b0123456789876543210 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210 b0123456789876543210 ns0123456789876543210 bs0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210 n0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 n0123456789876543210 b0123456789876543210 (ns0123456789876543210 :: [Nat]) (bs0123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 b0123456789876543210 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 b0123456789876543210 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (ns0123456789876543210 :: [Nat]) (bs0123456789876543210 :: [Bool]) a_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 ns bs n b = Apply (LamCases_0123456789876543210Sym0 n b ns bs) b
+    data LamCases_0123456789876543210Sym0 (ns0123456789876543210 :: [Nat]) (bs0123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210) arg) (Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210 n0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210) n0123456789876543210 = Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 n0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 ns0123456789876543210 bs0123456789876543210) arg) (LamCases_0123456789876543210Sym1 ns0123456789876543210 bs0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 ns0123456789876543210 bs0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210Sym1 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 ns0123456789876543210 bs0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 n0123456789876543210 b0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    data LamCases_0123456789876543210Sym1 (ns0123456789876543210 :: [Nat]) (bs0123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 n0123456789876543210) arg) (Lambda_0123456789876543210Sym4 ns0123456789876543210 bs0123456789876543210 n0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 n0123456789876543210 b0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 n0123456789876543210) b0123456789876543210 = Lambda_0123456789876543210 ns0123456789876543210 bs0123456789876543210 n0123456789876543210 b0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 n0123456789876543210) where
+        LamCases_0123456789876543210Sym1KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym1 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym1 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym1 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym1 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    type family Lambda_0123456789876543210Sym4 ns0123456789876543210 bs0123456789876543210 n0123456789876543210 b0123456789876543210 where
-      Lambda_0123456789876543210Sym4 ns0123456789876543210 bs0123456789876543210 n0123456789876543210 b0123456789876543210 = Lambda_0123456789876543210 ns0123456789876543210 bs0123456789876543210 n0123456789876543210 b0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym1KindInference ())
+    type family LamCases_0123456789876543210Sym2 (ns0123456789876543210 :: [Nat]) (bs0123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 ns0123456789876543210 bs0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
     type EtadSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])
     data EtadSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])
       where
         EtadSym0KindInference :: SameKind (Apply EtadSym0 arg) (EtadSym1 arg) =>
                                  EtadSym0 a0123456789876543210
-    type instance Apply EtadSym0 a0123456789876543210 = EtadSym1 a0123456789876543210
+    type instance Apply @[Nat] @((~>) [Bool] [Nat]) EtadSym0 a0123456789876543210 = EtadSym1 a0123456789876543210
     instance SuppressUnusedWarnings EtadSym0 where
-      suppressUnusedWarnings = snd (((,) EtadSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) EtadSym0KindInference ())
     type EtadSym1 :: [Nat] -> (~>) [Bool] [Nat]
     data EtadSym1 (a0123456789876543210 :: [Nat]) :: (~>) [Bool] [Nat]
       where
         EtadSym1KindInference :: SameKind (Apply (EtadSym1 a0123456789876543210) arg) (EtadSym2 a0123456789876543210 arg) =>
                                  EtadSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (EtadSym1 a0123456789876543210) a0123456789876543210 = Etad a0123456789876543210 a0123456789876543210
+    type instance Apply @[Bool] @[Nat] (EtadSym1 a0123456789876543210) a0123456789876543210 = Etad a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (EtadSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) EtadSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) EtadSym1KindInference ())
     type EtadSym2 :: [Nat] -> [Bool] -> [Nat]
     type family EtadSym2 (a0123456789876543210 :: [Nat]) (a0123456789876543210 :: [Bool]) :: [Nat] where
       EtadSym2 a0123456789876543210 a0123456789876543210 = Etad a0123456789876543210 a0123456789876543210
@@ -164,17 +152,17 @@
       where
         SplungeSym0KindInference :: SameKind (Apply SplungeSym0 arg) (SplungeSym1 arg) =>
                                     SplungeSym0 a0123456789876543210
-    type instance Apply SplungeSym0 a0123456789876543210 = SplungeSym1 a0123456789876543210
+    type instance Apply @[Nat] @((~>) [Bool] [Nat]) SplungeSym0 a0123456789876543210 = SplungeSym1 a0123456789876543210
     instance SuppressUnusedWarnings SplungeSym0 where
-      suppressUnusedWarnings = snd (((,) SplungeSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SplungeSym0KindInference ())
     type SplungeSym1 :: [Nat] -> (~>) [Bool] [Nat]
     data SplungeSym1 (a0123456789876543210 :: [Nat]) :: (~>) [Bool] [Nat]
       where
         SplungeSym1KindInference :: SameKind (Apply (SplungeSym1 a0123456789876543210) arg) (SplungeSym2 a0123456789876543210 arg) =>
                                     SplungeSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (SplungeSym1 a0123456789876543210) a0123456789876543210 = Splunge a0123456789876543210 a0123456789876543210
+    type instance Apply @[Bool] @[Nat] (SplungeSym1 a0123456789876543210) a0123456789876543210 = Splunge a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (SplungeSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) SplungeSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) SplungeSym1KindInference ())
     type SplungeSym2 :: [Nat] -> [Bool] -> [Nat]
     type family SplungeSym2 (a0123456789876543210 :: [Nat]) (a0123456789876543210 :: [Bool]) :: [Nat] where
       SplungeSym2 a0123456789876543210 a0123456789876543210 = Splunge a0123456789876543210 a0123456789876543210
@@ -183,299 +171,299 @@
       where
         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
                                 FooSym0 a0123456789876543210
-    type instance Apply FooSym0 a0123456789876543210 = FooSym1 a0123456789876543210
+    type instance Apply @((~>) ((~>) a b) ((~>) a b)) @((~>) ((~>) a b) ((~>) a b)) FooSym0 a0123456789876543210 = FooSym1 a0123456789876543210
     instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
     type FooSym1 :: (~>) ((~>) a b) ((~>) a b)
                     -> (~>) ((~>) a b) ((~>) a b)
     data FooSym1 (a0123456789876543210 :: (~>) ((~>) a b) ((~>) a b)) :: (~>) ((~>) a b) ((~>) a b)
       where
         FooSym1KindInference :: SameKind (Apply (FooSym1 a0123456789876543210) arg) (FooSym2 a0123456789876543210 arg) =>
                                 FooSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FooSym1 a0123456789876543210) a0123456789876543210 = FooSym2 a0123456789876543210 a0123456789876543210
+    type instance Apply @((~>) a b) @((~>) a b) (FooSym1 a0123456789876543210) a0123456789876543210 = FooSym2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (FooSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FooSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym1KindInference ())
     type FooSym2 :: (~>) ((~>) a b) ((~>) a b) -> (~>) a b -> (~>) a b
     data FooSym2 (a0123456789876543210 :: (~>) ((~>) a b) ((~>) a b)) (a0123456789876543210 :: (~>) a b) :: (~>) a b
       where
         FooSym2KindInference :: SameKind (Apply (FooSym2 a0123456789876543210 a0123456789876543210) arg) (FooSym3 a0123456789876543210 a0123456789876543210 arg) =>
                                 FooSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (FooSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = Foo a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @a @b (FooSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = Foo a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (FooSym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FooSym2KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym2KindInference ())
     type FooSym3 :: (~>) ((~>) a b) ((~>) a b) -> (~>) a b -> a -> b
-    type family FooSym3 (a0123456789876543210 :: (~>) ((~>) a b) ((~>) a b)) (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: a) :: b where
+    type family FooSym3 @a @b (a0123456789876543210 :: (~>) ((~>) a b) ((~>) a b)) (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: a) :: b where
       FooSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = Foo a0123456789876543210 a0123456789876543210 a0123456789876543210
     type ZipWithSym0 :: (~>) ((~>) a ((~>) b c)) ((~>) [a] ((~>) [b] [c]))
     data ZipWithSym0 :: (~>) ((~>) a ((~>) b c)) ((~>) [a] ((~>) [b] [c]))
       where
         ZipWithSym0KindInference :: SameKind (Apply ZipWithSym0 arg) (ZipWithSym1 arg) =>
                                     ZipWithSym0 a0123456789876543210
-    type instance Apply ZipWithSym0 a0123456789876543210 = ZipWithSym1 a0123456789876543210
+    type instance Apply @((~>) a ((~>) b c)) @((~>) [a] ((~>) [b] [c])) ZipWithSym0 a0123456789876543210 = ZipWithSym1 a0123456789876543210
     instance SuppressUnusedWarnings ZipWithSym0 where
-      suppressUnusedWarnings = snd (((,) ZipWithSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) ZipWithSym0KindInference ())
     type ZipWithSym1 :: (~>) a ((~>) b c) -> (~>) [a] ((~>) [b] [c])
     data ZipWithSym1 (a0123456789876543210 :: (~>) a ((~>) b c)) :: (~>) [a] ((~>) [b] [c])
       where
         ZipWithSym1KindInference :: SameKind (Apply (ZipWithSym1 a0123456789876543210) arg) (ZipWithSym2 a0123456789876543210 arg) =>
                                     ZipWithSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ZipWithSym1 a0123456789876543210) a0123456789876543210 = ZipWithSym2 a0123456789876543210 a0123456789876543210
+    type instance Apply @[a] @((~>) [b] [c]) (ZipWithSym1 a0123456789876543210) a0123456789876543210 = ZipWithSym2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (ZipWithSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ZipWithSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) ZipWithSym1KindInference ())
     type ZipWithSym2 :: (~>) a ((~>) b c) -> [a] -> (~>) [b] [c]
     data ZipWithSym2 (a0123456789876543210 :: (~>) a ((~>) b c)) (a0123456789876543210 :: [a]) :: (~>) [b] [c]
       where
         ZipWithSym2KindInference :: SameKind (Apply (ZipWithSym2 a0123456789876543210 a0123456789876543210) arg) (ZipWithSym3 a0123456789876543210 a0123456789876543210 arg) =>
                                     ZipWithSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ZipWithSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ZipWith a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @[b] @[c] (ZipWithSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ZipWith a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (ZipWithSym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ZipWithSym2KindInference) ())
+      suppressUnusedWarnings = snd ((,) ZipWithSym2KindInference ())
     type ZipWithSym3 :: (~>) a ((~>) b c) -> [a] -> [b] -> [c]
-    type family ZipWithSym3 (a0123456789876543210 :: (~>) a ((~>) b c)) (a0123456789876543210 :: [a]) (a0123456789876543210 :: [b]) :: [c] where
+    type family ZipWithSym3 @a @b @c (a0123456789876543210 :: (~>) a ((~>) b c)) (a0123456789876543210 :: [a]) (a0123456789876543210 :: [b]) :: [c] where
       ZipWithSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ZipWith a0123456789876543210 a0123456789876543210 a0123456789876543210
     type LiftMaybeSym0 :: (~>) ((~>) a b) ((~>) (Maybe a) (Maybe b))
     data LiftMaybeSym0 :: (~>) ((~>) a b) ((~>) (Maybe a) (Maybe b))
       where
         LiftMaybeSym0KindInference :: SameKind (Apply LiftMaybeSym0 arg) (LiftMaybeSym1 arg) =>
                                       LiftMaybeSym0 a0123456789876543210
-    type instance Apply LiftMaybeSym0 a0123456789876543210 = LiftMaybeSym1 a0123456789876543210
+    type instance Apply @((~>) a b) @((~>) (Maybe a) (Maybe b)) LiftMaybeSym0 a0123456789876543210 = LiftMaybeSym1 a0123456789876543210
     instance SuppressUnusedWarnings LiftMaybeSym0 where
-      suppressUnusedWarnings = snd (((,) LiftMaybeSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) LiftMaybeSym0KindInference ())
     type LiftMaybeSym1 :: (~>) a b -> (~>) (Maybe a) (Maybe b)
     data LiftMaybeSym1 (a0123456789876543210 :: (~>) a b) :: (~>) (Maybe a) (Maybe b)
       where
         LiftMaybeSym1KindInference :: SameKind (Apply (LiftMaybeSym1 a0123456789876543210) arg) (LiftMaybeSym2 a0123456789876543210 arg) =>
                                       LiftMaybeSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (LiftMaybeSym1 a0123456789876543210) a0123456789876543210 = LiftMaybe a0123456789876543210 a0123456789876543210
+    type instance Apply @(Maybe a) @(Maybe b) (LiftMaybeSym1 a0123456789876543210) a0123456789876543210 = LiftMaybe a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (LiftMaybeSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) LiftMaybeSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) LiftMaybeSym1KindInference ())
     type LiftMaybeSym2 :: (~>) a b -> Maybe a -> Maybe b
-    type family LiftMaybeSym2 (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: Maybe a) :: Maybe b where
+    type family LiftMaybeSym2 @a @b (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: Maybe a) :: Maybe b where
       LiftMaybeSym2 a0123456789876543210 a0123456789876543210 = LiftMaybe a0123456789876543210 a0123456789876543210
     type MapSym0 :: (~>) ((~>) a b) ((~>) [a] [b])
     data MapSym0 :: (~>) ((~>) a b) ((~>) [a] [b])
       where
         MapSym0KindInference :: SameKind (Apply MapSym0 arg) (MapSym1 arg) =>
                                 MapSym0 a0123456789876543210
-    type instance Apply MapSym0 a0123456789876543210 = MapSym1 a0123456789876543210
+    type instance Apply @((~>) a b) @((~>) [a] [b]) MapSym0 a0123456789876543210 = MapSym1 a0123456789876543210
     instance SuppressUnusedWarnings MapSym0 where
-      suppressUnusedWarnings = snd (((,) MapSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MapSym0KindInference ())
     type MapSym1 :: (~>) a b -> (~>) [a] [b]
     data MapSym1 (a0123456789876543210 :: (~>) a b) :: (~>) [a] [b]
       where
         MapSym1KindInference :: SameKind (Apply (MapSym1 a0123456789876543210) arg) (MapSym2 a0123456789876543210 arg) =>
                                 MapSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MapSym1 a0123456789876543210) a0123456789876543210 = Map a0123456789876543210 a0123456789876543210
+    type instance Apply @[a] @[b] (MapSym1 a0123456789876543210) a0123456789876543210 = Map a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MapSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MapSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) MapSym1KindInference ())
     type MapSym2 :: (~>) a b -> [a] -> [b]
-    type family MapSym2 (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: [a]) :: [b] where
+    type family MapSym2 @a @b (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: [a]) :: [b] where
       MapSym2 a0123456789876543210 a0123456789876543210 = Map a0123456789876543210 a0123456789876543210
     type Etad :: [Nat] -> [Bool] -> [Nat]
     type family Etad (a :: [Nat]) (a :: [Bool]) :: [Nat] where
-      Etad a_0123456789876543210 a_0123456789876543210 = Apply (Apply (Apply ZipWithSym0 (Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210)) a_0123456789876543210) a_0123456789876543210
+      Etad a_0123456789876543210 a_0123456789876543210 = Apply (Apply (Apply ZipWithSym0 (LamCases_0123456789876543210Sym0 a_0123456789876543210 a_0123456789876543210)) a_0123456789876543210) a_0123456789876543210
     type Splunge :: [Nat] -> [Bool] -> [Nat]
     type family Splunge (a :: [Nat]) (a :: [Bool]) :: [Nat] where
-      Splunge ns bs = Apply (Apply (Apply ZipWithSym0 (Apply (Apply Lambda_0123456789876543210Sym0 ns) bs)) ns) bs
+      Splunge ns bs = Apply (Apply (Apply ZipWithSym0 (LamCases_0123456789876543210Sym0 ns bs)) ns) bs
     type Foo :: (~>) ((~>) a b) ((~>) a b) -> (~>) a b -> a -> b
-    type family Foo (a :: (~>) ((~>) a b) ((~>) a b)) (a :: (~>) a b) (a :: a) :: b where
+    type family Foo @a @b (a :: (~>) ((~>) a b) ((~>) a b)) (a :: (~>) a b) (a :: a) :: b where
       Foo f g a = Apply (Apply f g) a
     type ZipWith :: (~>) a ((~>) b c) -> [a] -> [b] -> [c]
-    type family ZipWith (a :: (~>) a ((~>) b c)) (a :: [a]) (a :: [b]) :: [c] where
+    type family ZipWith @a @b @c (a :: (~>) a ((~>) b c)) (a :: [a]) (a :: [b]) :: [c] where
       ZipWith f ('(:) x xs) ('(:) y ys) = Apply (Apply (:@#@$) (Apply (Apply f x) y)) (Apply (Apply (Apply ZipWithSym0 f) xs) ys)
       ZipWith _ '[] '[] = NilSym0
       ZipWith _ ('(:) _ _) '[] = NilSym0
       ZipWith _ '[] ('(:) _ _) = NilSym0
     type LiftMaybe :: (~>) a b -> Maybe a -> Maybe b
-    type family LiftMaybe (a :: (~>) a b) (a :: Maybe a) :: Maybe b where
+    type family LiftMaybe @a @b (a :: (~>) a b) (a :: Maybe a) :: Maybe b where
       LiftMaybe f ('Just x) = Apply JustSym0 (Apply f x)
       LiftMaybe _ 'Nothing = NothingSym0
     type Map :: (~>) a b -> [a] -> [b]
-    type family Map (a :: (~>) a b) (a :: [a]) :: [b] where
+    type family Map @a @b (a :: (~>) a b) (a :: [a]) :: [b] where
       Map _ '[] = NilSym0
       Map f ('(:) h t) = Apply (Apply (:@#@$) (Apply f h)) (Apply (Apply MapSym0 f) t)
     sEtad ::
-      forall (t :: [Nat]) (t :: [Bool]). Sing t
-                                         -> Sing t -> Sing (Apply (Apply EtadSym0 t) t :: [Nat])
+      (forall (t :: [Nat]) (t :: [Bool]).
+       Sing t -> Sing t -> Sing (Etad t t :: [Nat]) :: Type)
     sSplunge ::
-      forall (t :: [Nat]) (t :: [Bool]). Sing t
-                                         -> Sing t -> Sing (Apply (Apply SplungeSym0 t) t :: [Nat])
+      (forall (t :: [Nat]) (t :: [Bool]).
+       Sing t -> Sing t -> Sing (Splunge t t :: [Nat]) :: Type)
     sFoo ::
-      forall a
-             b
-             (t :: (~>) ((~>) a b) ((~>) a b))
-             (t :: (~>) a b)
-             (t :: a). Sing t
-                       -> Sing t
-                          -> Sing t -> Sing (Apply (Apply (Apply FooSym0 t) t) t :: b)
+      (forall (t :: (~>) ((~>) a b) ((~>) a b)) (t :: (~>) a b) (t :: a).
+       Sing t -> Sing t -> Sing t -> Sing (Foo t t t :: b) :: Type)
     sZipWith ::
-      forall a b c (t :: (~>) a ((~>) b c)) (t :: [a]) (t :: [b]). Sing t
-                                                                   -> Sing t
-                                                                      -> Sing t
-                                                                         -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c])
+      (forall (t :: (~>) a ((~>) b c)) (t :: [a]) (t :: [b]).
+       Sing t -> Sing t -> Sing t -> Sing (ZipWith t t t :: [c]) :: Type)
     sLiftMaybe ::
-      forall a b (t :: (~>) a b) (t :: Maybe a). Sing t
-                                                 -> Sing t
-                                                    -> Sing (Apply (Apply LiftMaybeSym0 t) t :: Maybe b)
+      (forall (t :: (~>) a b) (t :: Maybe a).
+       Sing t -> Sing t -> Sing (LiftMaybe t t :: Maybe b) :: Type)
     sMap ::
-      forall a b (t :: (~>) a b) (t :: [a]). Sing t
-                                             -> Sing t -> Sing (Apply (Apply MapSym0 t) t :: [b])
+      (forall (t :: (~>) a b) (t :: [a]).
+       Sing t -> Sing t -> Sing (Map t t :: [b]) :: Type)
     sEtad
       (sA_0123456789876543210 :: Sing a_0123456789876543210)
       (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing
-           ((applySing
-               ((applySing ((singFun3 @ZipWithSym0) sZipWith))
-                  ((singFun2
-                      @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210))
-                     (\ sN sB
-                        -> case ((,) sN) sB of
-                             (,) (_ :: Sing n) (_ :: Sing b)
-                               -> (id
-                                     @(Sing (Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 b)))
-                                    (case sB of
-                                       STrue
-                                         -> (applySing ((singFun1 @SuccSym0) SSucc))
-                                              ((applySing ((singFun1 @SuccSym0) SSucc)) sN)
-                                       SFalse -> sN)))))
-              sA_0123456789876543210))
+      = applySing
+          (applySing
+             (applySing
+                (singFun3 @ZipWithSym0 sZipWith)
+                (singFun2
+                   @(LamCases_0123456789876543210Sym0 a_0123456789876543210 a_0123456789876543210)
+                   (\cases
+                      (sN :: Sing n) (sB :: Sing b)
+                        -> applySing
+                             (singFun1
+                                @(LamCases_0123456789876543210Sym0 n b a_0123456789876543210 a_0123456789876543210)
+                                (\cases
+                                   STrue
+                                     -> applySing
+                                          (singFun1 @SuccSym0 SSucc)
+                                          (applySing (singFun1 @SuccSym0 SSucc) sN)
+                                   SFalse -> sN))
+                             sB)))
+             sA_0123456789876543210)
           sA_0123456789876543210
     sSplunge (sNs :: Sing ns) (sBs :: Sing bs)
-      = (applySing
-           ((applySing
-               ((applySing ((singFun3 @ZipWithSym0) sZipWith))
-                  ((singFun2 @(Apply (Apply Lambda_0123456789876543210Sym0 ns) bs))
-                     (\ sN sB
-                        -> case ((,) sN) sB of
-                             (,) (_ :: Sing n) (_ :: Sing b)
-                               -> (id @(Sing (Case_0123456789876543210 n b ns bs b)))
-                                    (case sB of
-                                       STrue
-                                         -> (applySing ((singFun1 @SuccSym0) SSucc))
-                                              ((applySing ((singFun1 @SuccSym0) SSucc)) sN)
-                                       SFalse -> sN)))))
-              sNs))
+      = applySing
+          (applySing
+             (applySing
+                (singFun3 @ZipWithSym0 sZipWith)
+                (singFun2
+                   @(LamCases_0123456789876543210Sym0 ns bs)
+                   (\cases
+                      (sN :: Sing n) (sB :: Sing b)
+                        -> applySing
+                             (singFun1
+                                @(LamCases_0123456789876543210Sym0 n b ns bs)
+                                (\cases
+                                   STrue
+                                     -> applySing
+                                          (singFun1 @SuccSym0 SSucc)
+                                          (applySing (singFun1 @SuccSym0 SSucc) sN)
+                                   SFalse -> sN))
+                             sB)))
+             sNs)
           sBs
     sFoo (sF :: Sing f) (sG :: Sing g) (sA :: Sing a)
-      = (applySing ((applySing sF) sG)) sA
+      = applySing (applySing sF sG) sA
     sZipWith
       (sF :: Sing f)
       (SCons (sX :: Sing x) (sXs :: Sing xs))
       (SCons (sY :: Sing y) (sYs :: Sing ys))
-      = (applySing
-           ((applySing ((singFun2 @(:@#@$)) SCons))
-              ((applySing ((applySing sF) sX)) sY)))
-          ((applySing
-              ((applySing ((applySing ((singFun3 @ZipWithSym0) sZipWith)) sF))
-                 sXs))
+      = applySing
+          (applySing
+             (singFun2 @(:@#@$) SCons) (applySing (applySing sF sX) sY))
+          (applySing
+             (applySing (applySing (singFun3 @ZipWithSym0 sZipWith) sF) sXs)
              sYs)
     sZipWith _ SNil SNil = SNil
     sZipWith _ (SCons _ _) SNil = SNil
     sZipWith _ SNil (SCons _ _) = SNil
     sLiftMaybe (sF :: Sing f) (SJust (sX :: Sing x))
-      = (applySing ((singFun1 @JustSym0) SJust)) ((applySing sF) sX)
+      = applySing (singFun1 @JustSym0 SJust) (applySing sF sX)
     sLiftMaybe _ SNothing = SNothing
     sMap _ SNil = SNil
     sMap (sF :: Sing f) (SCons (sH :: Sing h) (sT :: Sing t))
-      = (applySing
-           ((applySing ((singFun2 @(:@#@$)) SCons)) ((applySing sF) sH)))
-          ((applySing ((applySing ((singFun2 @MapSym0) sMap)) sF)) sT)
+      = applySing
+          (applySing (singFun2 @(:@#@$) SCons) (applySing sF sH))
+          (applySing (applySing (singFun2 @MapSym0 sMap) sF) sT)
     instance SingI (EtadSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])) where
-      sing = (singFun2 @EtadSym0) sEtad
+      sing = singFun2 @EtadSym0 sEtad
     instance SingI d =>
              SingI (EtadSym1 (d :: [Nat]) :: (~>) [Bool] [Nat]) where
-      sing = (singFun1 @(EtadSym1 (d :: [Nat]))) (sEtad (sing @d))
+      sing = singFun1 @(EtadSym1 (d :: [Nat])) (sEtad (sing @d))
     instance SingI1 (EtadSym1 :: [Nat] -> (~>) [Bool] [Nat]) where
       liftSing (s :: Sing (d :: [Nat]))
-        = (singFun1 @(EtadSym1 (d :: [Nat]))) (sEtad s)
+        = singFun1 @(EtadSym1 (d :: [Nat])) (sEtad s)
     instance SingI (SplungeSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])) where
-      sing = (singFun2 @SplungeSym0) sSplunge
+      sing = singFun2 @SplungeSym0 sSplunge
     instance SingI d =>
              SingI (SplungeSym1 (d :: [Nat]) :: (~>) [Bool] [Nat]) where
-      sing = (singFun1 @(SplungeSym1 (d :: [Nat]))) (sSplunge (sing @d))
+      sing = singFun1 @(SplungeSym1 (d :: [Nat])) (sSplunge (sing @d))
     instance SingI1 (SplungeSym1 :: [Nat] -> (~>) [Bool] [Nat]) where
       liftSing (s :: Sing (d :: [Nat]))
-        = (singFun1 @(SplungeSym1 (d :: [Nat]))) (sSplunge s)
+        = singFun1 @(SplungeSym1 (d :: [Nat])) (sSplunge s)
     instance SingI (FooSym0 :: (~>) ((~>) ((~>) a b) ((~>) a b)) ((~>) ((~>) a b) ((~>) a b))) where
-      sing = (singFun3 @FooSym0) sFoo
+      sing = singFun3 @FooSym0 sFoo
     instance SingI d =>
              SingI (FooSym1 (d :: (~>) ((~>) a b) ((~>) a b)) :: (~>) ((~>) a b) ((~>) a b)) where
       sing
-        = (singFun2 @(FooSym1 (d :: (~>) ((~>) a b) ((~>) a b))))
-            (sFoo (sing @d))
+        = singFun2
+            @(FooSym1 (d :: (~>) ((~>) a b) ((~>) a b))) (sFoo (sing @d))
     instance SingI1 (FooSym1 :: (~>) ((~>) a b) ((~>) a b)
                                 -> (~>) ((~>) a b) ((~>) a b)) where
       liftSing (s :: Sing (d :: (~>) ((~>) a b) ((~>) a b)))
-        = (singFun2 @(FooSym1 (d :: (~>) ((~>) a b) ((~>) a b)))) (sFoo s)
+        = singFun2 @(FooSym1 (d :: (~>) ((~>) a b) ((~>) a b))) (sFoo s)
     instance (SingI d, SingI d) =>
              SingI (FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b) :: (~>) a b) where
       sing
-        = (singFun1
-             @(FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b)))
-            ((sFoo (sing @d)) (sing @d))
+        = singFun1
+            @(FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b))
+            (sFoo (sing @d) (sing @d))
     instance SingI d =>
              SingI1 (FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) :: (~>) a b
                                                                   -> (~>) a b) where
       liftSing (s :: Sing (d :: (~>) a b))
-        = (singFun1
-             @(FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b)))
-            ((sFoo (sing @d)) s)
+        = singFun1
+            @(FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b))
+            (sFoo (sing @d) s)
     instance SingI2 (FooSym2 :: (~>) ((~>) a b) ((~>) a b)
                                 -> (~>) a b -> (~>) a b) where
       liftSing2
         (s :: Sing (d :: (~>) ((~>) a b) ((~>) a b)))
         (s :: Sing (d :: (~>) a b))
-        = (singFun1
-             @(FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b)))
-            ((sFoo s) s)
+        = singFun1
+            @(FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b))
+            (sFoo s s)
     instance SingI (ZipWithSym0 :: (~>) ((~>) a ((~>) b c)) ((~>) [a] ((~>) [b] [c]))) where
-      sing = (singFun3 @ZipWithSym0) sZipWith
+      sing = singFun3 @ZipWithSym0 sZipWith
     instance SingI d =>
              SingI (ZipWithSym1 (d :: (~>) a ((~>) b c)) :: (~>) [a] ((~>) [b] [c])) where
       sing
-        = (singFun2 @(ZipWithSym1 (d :: (~>) a ((~>) b c))))
-            (sZipWith (sing @d))
+        = singFun2
+            @(ZipWithSym1 (d :: (~>) a ((~>) b c))) (sZipWith (sing @d))
     instance SingI1 (ZipWithSym1 :: (~>) a ((~>) b c)
                                     -> (~>) [a] ((~>) [b] [c])) where
       liftSing (s :: Sing (d :: (~>) a ((~>) b c)))
-        = (singFun2 @(ZipWithSym1 (d :: (~>) a ((~>) b c)))) (sZipWith s)
+        = singFun2 @(ZipWithSym1 (d :: (~>) a ((~>) b c))) (sZipWith s)
     instance (SingI d, SingI d) =>
              SingI (ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a]) :: (~>) [b] [c]) where
       sing
-        = (singFun1 @(ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a])))
-            ((sZipWith (sing @d)) (sing @d))
+        = singFun1
+            @(ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a]))
+            (sZipWith (sing @d) (sing @d))
     instance SingI d =>
              SingI1 (ZipWithSym2 (d :: (~>) a ((~>) b c)) :: [a]
                                                              -> (~>) [b] [c]) where
       liftSing (s :: Sing (d :: [a]))
-        = (singFun1 @(ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a])))
-            ((sZipWith (sing @d)) s)
+        = singFun1
+            @(ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a]))
+            (sZipWith (sing @d) s)
     instance SingI2 (ZipWithSym2 :: (~>) a ((~>) b c)
                                     -> [a] -> (~>) [b] [c]) where
       liftSing2
         (s :: Sing (d :: (~>) a ((~>) b c)))
         (s :: Sing (d :: [a]))
-        = (singFun1 @(ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a])))
-            ((sZipWith s) s)
+        = singFun1
+            @(ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a])) (sZipWith s s)
     instance SingI (LiftMaybeSym0 :: (~>) ((~>) a b) ((~>) (Maybe a) (Maybe b))) where
-      sing = (singFun2 @LiftMaybeSym0) sLiftMaybe
+      sing = singFun2 @LiftMaybeSym0 sLiftMaybe
     instance SingI d =>
              SingI (LiftMaybeSym1 (d :: (~>) a b) :: (~>) (Maybe a) (Maybe b)) where
       sing
-        = (singFun1 @(LiftMaybeSym1 (d :: (~>) a b)))
-            (sLiftMaybe (sing @d))
+        = singFun1 @(LiftMaybeSym1 (d :: (~>) a b)) (sLiftMaybe (sing @d))
     instance SingI1 (LiftMaybeSym1 :: (~>) a b
                                       -> (~>) (Maybe a) (Maybe b)) where
       liftSing (s :: Sing (d :: (~>) a b))
-        = (singFun1 @(LiftMaybeSym1 (d :: (~>) a b))) (sLiftMaybe s)
+        = singFun1 @(LiftMaybeSym1 (d :: (~>) a b)) (sLiftMaybe s)
     instance SingI (MapSym0 :: (~>) ((~>) a b) ((~>) [a] [b])) where
-      sing = (singFun2 @MapSym0) sMap
+      sing = singFun2 @MapSym0 sMap
     instance SingI d =>
              SingI (MapSym1 (d :: (~>) a b) :: (~>) [a] [b]) where
-      sing = (singFun1 @(MapSym1 (d :: (~>) a b))) (sMap (sing @d))
+      sing = singFun1 @(MapSym1 (d :: (~>) a b)) (sMap (sing @d))
     instance SingI1 (MapSym1 :: (~>) a b -> (~>) [a] [b]) where
       liftSing (s :: Sing (d :: (~>) a b))
-        = (singFun1 @(MapSym1 (d :: (~>) a b))) (sMap s)
+        = singFun1 @(MapSym1 (d :: (~>) a b)) (sMap s)
     data SEither :: forall a b. Either a b -> Type
       where
         SLeft :: forall a b (n :: a).
@@ -488,18 +476,20 @@
       fromSing (SLeft b) = Left (fromSing b)
       fromSing (SRight b) = Right (fromSing b)
       toSing (Left (b :: Demote a))
-        = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SLeft c)
+        = (\cases (SomeSing c) -> SomeSing (SLeft c))
+            (toSing b :: SomeSing a)
       toSing (Right (b :: Demote b))
-        = case toSing b :: SomeSing b of SomeSing c -> SomeSing (SRight c)
+        = (\cases (SomeSing c) -> SomeSing (SRight c))
+            (toSing b :: SomeSing b)
     instance SingI n => SingI (Left (n :: a)) where
       sing = SLeft sing
     instance SingI1 Left where
       liftSing = SLeft
     instance SingI (LeftSym0 :: (~>) a (Either a b)) where
-      sing = (singFun1 @LeftSym0) SLeft
+      sing = singFun1 @LeftSym0 SLeft
     instance SingI n => SingI (Right (n :: b)) where
       sing = SRight sing
     instance SingI1 Right where
       liftSing = SRight
     instance SingI (RightSym0 :: (~>) b (Either a b)) where
-      sing = (singFun1 @RightSym0) SRight
+      sing = singFun1 @RightSym0 SRight
diff --git a/tests/compile-and-dump/Singletons/LambdaCase.golden b/tests/compile-and-dump/Singletons/LambdaCase.golden
--- a/tests/compile-and-dump/Singletons/LambdaCase.golden
+++ b/tests/compile-and-dump/Singletons/LambdaCase.golden
@@ -29,219 +29,161 @@
           (Just d)
     foo3 :: a -> b -> a
     foo3 a b = (\case (p, _) -> p) (a, b)
-    type family Case_0123456789876543210 x_0123456789876543210 a b t where
-      Case_0123456789876543210 x_0123456789876543210 a b '(p, _) = p
-    type family Lambda_0123456789876543210 a b x_0123456789876543210 where
-      Lambda_0123456789876543210 a b x_0123456789876543210 = Case_0123456789876543210 x_0123456789876543210 a b x_0123456789876543210
-    data Lambda_0123456789876543210Sym0 a0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 a0123456789876543210 = Lambda_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 a0123456789876543210) arg) (Lambda_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 a0123456789876543210) b0123456789876543210 = Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 x_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 x_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) x_01234567898765432100123456789876543210 = Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 x_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x_01234567898765432100123456789876543210 = Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 x_01234567898765432100123456789876543210
-    type family Case_0123456789876543210 x_0123456789876543210 d t where
-      Case_0123456789876543210 x_0123456789876543210 d ('Just y) = y
-      Case_0123456789876543210 x_0123456789876543210 d 'Nothing = d
-    type family Lambda_0123456789876543210 d x_0123456789876543210 where
-      Lambda_0123456789876543210 d x_0123456789876543210 = Case_0123456789876543210 x_0123456789876543210 d x_0123456789876543210
-    data Lambda_0123456789876543210Sym0 d0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 d0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 d0123456789876543210 = Lambda_0123456789876543210Sym1 d0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 d0123456789876543210 x_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 d0123456789876543210) arg) (Lambda_0123456789876543210Sym2 d0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 d0123456789876543210 x_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 d0123456789876543210) x_01234567898765432100123456789876543210 = Lambda_0123456789876543210 d0123456789876543210 x_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 d0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    type family Lambda_0123456789876543210Sym2 d0123456789876543210 x_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym2 d0123456789876543210 x_01234567898765432100123456789876543210 = Lambda_0123456789876543210 d0123456789876543210 x_01234567898765432100123456789876543210
-    type family Case_0123456789876543210 x_0123456789876543210 d x t where
-      Case_0123456789876543210 x_0123456789876543210 d x ('Just y) = y
-      Case_0123456789876543210 x_0123456789876543210 d x 'Nothing = d
-    type family Lambda_0123456789876543210 d x x_0123456789876543210 where
-      Lambda_0123456789876543210 d x x_0123456789876543210 = Case_0123456789876543210 x_0123456789876543210 d x x_0123456789876543210
-    data Lambda_0123456789876543210Sym0 d0123456789876543210
+    type family LamCases_0123456789876543210 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 a b '(p, _) = p
+    data LamCases_0123456789876543210Sym0 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 d0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 d0123456789876543210 = Lambda_0123456789876543210Sym1 d0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 d0123456789876543210 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (d0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 d ('Just y) = y
+      LamCases_0123456789876543210 d 'Nothing = d
+    data LamCases_0123456789876543210Sym0 (d0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 d0123456789876543210) arg) (Lambda_0123456789876543210Sym2 d0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 d0123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 d0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 d0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 d0123456789876543210) arg) (LamCases_0123456789876543210Sym1 d0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 d0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 d0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 d0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 d0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210 x_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (d0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 d0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 d0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (d0123456789876543210 :: a0123456789876543210) (x0123456789876543210 :: Maybe a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 d x ('Just y) = y
+      LamCases_0123456789876543210 d x 'Nothing = d
+    data LamCases_0123456789876543210Sym0 (d0123456789876543210 :: a0123456789876543210) (x0123456789876543210 :: Maybe a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210) arg) (Lambda_0123456789876543210Sym3 d0123456789876543210 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210 x_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210) x_01234567898765432100123456789876543210 = Lambda_0123456789876543210 d0123456789876543210 x0123456789876543210 x_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 d0123456789876543210 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 d0123456789876543210 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 d0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 d0123456789876543210 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 d0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 d0123456789876543210 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 d0123456789876543210 x0123456789876543210 x_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym3 d0123456789876543210 x0123456789876543210 x_01234567898765432100123456789876543210 = Lambda_0123456789876543210 d0123456789876543210 x0123456789876543210 x_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (d0123456789876543210 :: a0123456789876543210) (x0123456789876543210 :: Maybe a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 d0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 d0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
     type Foo3Sym0 :: (~>) a ((~>) b a)
     data Foo3Sym0 :: (~>) a ((~>) b a)
       where
         Foo3Sym0KindInference :: SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>
                                  Foo3Sym0 a0123456789876543210
-    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b a) Foo3Sym0 a0123456789876543210 = Foo3Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo3Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo3Sym0KindInference ())
     type Foo3Sym1 :: a -> (~>) b a
     data Foo3Sym1 (a0123456789876543210 :: a) :: (~>) b a
       where
         Foo3Sym1KindInference :: SameKind (Apply (Foo3Sym1 a0123456789876543210) arg) (Foo3Sym2 a0123456789876543210 arg) =>
                                  Foo3Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo3Sym1 a0123456789876543210) a0123456789876543210 = Foo3 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @a (Foo3Sym1 a0123456789876543210) a0123456789876543210 = Foo3 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo3Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo3Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo3Sym1KindInference ())
     type Foo3Sym2 :: a -> b -> a
-    type family Foo3Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
+    type family Foo3Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
       Foo3Sym2 a0123456789876543210 a0123456789876543210 = Foo3 a0123456789876543210 a0123456789876543210
     type Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)
     data Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)
       where
         Foo2Sym0KindInference :: SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>
                                  Foo2Sym0 a0123456789876543210
-    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210
+    type instance Apply @a @((~>) (Maybe a) a) Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo2Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo2Sym0KindInference ())
     type Foo2Sym1 :: a -> (~>) (Maybe a) a
     data Foo2Sym1 (a0123456789876543210 :: a) :: (~>) (Maybe a) a
       where
         Foo2Sym1KindInference :: SameKind (Apply (Foo2Sym1 a0123456789876543210) arg) (Foo2Sym2 a0123456789876543210 arg) =>
                                  Foo2Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210
+    type instance Apply @(Maybe a) @a (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo2Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo2Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo2Sym1KindInference ())
     type Foo2Sym2 :: a -> Maybe a -> a
-    type family Foo2Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) :: a where
+    type family Foo2Sym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) :: a where
       Foo2Sym2 a0123456789876543210 a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210
     type Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)
     data Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)
       where
         Foo1Sym0KindInference :: SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>
                                  Foo1Sym0 a0123456789876543210
-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210
+    type instance Apply @a @((~>) (Maybe a) a) Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo1Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo1Sym0KindInference ())
     type Foo1Sym1 :: a -> (~>) (Maybe a) a
     data Foo1Sym1 (a0123456789876543210 :: a) :: (~>) (Maybe a) a
       where
         Foo1Sym1KindInference :: SameKind (Apply (Foo1Sym1 a0123456789876543210) arg) (Foo1Sym2 a0123456789876543210 arg) =>
                                  Foo1Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210
+    type instance Apply @(Maybe a) @a (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo1Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo1Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo1Sym1KindInference ())
     type Foo1Sym2 :: a -> Maybe a -> a
-    type family Foo1Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) :: a where
+    type family Foo1Sym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) :: a where
       Foo1Sym2 a0123456789876543210 a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210
     type Foo3 :: a -> b -> a
-    type family Foo3 (a :: a) (a :: b) :: a where
-      Foo3 a b = Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) (Apply (Apply Tuple2Sym0 a) b)
+    type family Foo3 @a @b (a :: a) (a :: b) :: a where
+      Foo3 a b = Apply (LamCases_0123456789876543210Sym0 a b) (Apply (Apply Tuple2Sym0 a) b)
     type Foo2 :: a -> Maybe a -> a
-    type family Foo2 (a :: a) (a :: Maybe a) :: a where
-      Foo2 d _ = Apply (Apply Lambda_0123456789876543210Sym0 d) (Apply JustSym0 d)
+    type family Foo2 @a (a :: a) (a :: Maybe a) :: a where
+      Foo2 d _ = Apply (LamCases_0123456789876543210Sym0 d) (Apply JustSym0 d)
     type Foo1 :: a -> Maybe a -> a
-    type family Foo1 (a :: a) (a :: Maybe a) :: a where
-      Foo1 d x = Apply (Apply (Apply Lambda_0123456789876543210Sym0 d) x) x
+    type family Foo1 @a (a :: a) (a :: Maybe a) :: a where
+      Foo1 d x = Apply (LamCases_0123456789876543210Sym0 d x) x
     sFoo3 ::
-      forall a b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a)
+      (forall (t :: a) (t :: b).
+       Sing t -> Sing t -> Sing (Foo3 t t :: a) :: Type)
     sFoo2 ::
-      forall a (t :: a) (t :: Maybe a). Sing t
-                                        -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)
+      (forall (t :: a) (t :: Maybe a).
+       Sing t -> Sing t -> Sing (Foo2 t t :: a) :: Type)
     sFoo1 ::
-      forall a (t :: a) (t :: Maybe a). Sing t
-                                        -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)
+      (forall (t :: a) (t :: Maybe a).
+       Sing t -> Sing t -> Sing (Foo1 t t :: a) :: Type)
     sFoo3 (sA :: Sing a) (sB :: Sing b)
-      = (applySing
-           ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 a) b))
-              (\ sX_0123456789876543210
-                 -> case sX_0123456789876543210 of
-                      (_ :: Sing x_0123456789876543210)
-                        -> (id
-                              @(Sing (Case_0123456789876543210 x_0123456789876543210 a b x_0123456789876543210)))
-                             (case sX_0123456789876543210 of STuple2 (sP :: Sing p) _ -> sP))))
-          ((applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sA)) sB)
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 a b)
+             (\cases (STuple2 (sP :: Sing p) _) -> sP))
+          (applySing (applySing (singFun2 @Tuple2Sym0 STuple2) sA) sB)
     sFoo2 (sD :: Sing d) _
-      = (applySing
-           ((singFun1 @(Apply Lambda_0123456789876543210Sym0 d))
-              (\ sX_0123456789876543210
-                 -> case sX_0123456789876543210 of
-                      (_ :: Sing x_0123456789876543210)
-                        -> (id
-                              @(Sing (Case_0123456789876543210 x_0123456789876543210 d x_0123456789876543210)))
-                             (case sX_0123456789876543210 of
-                                SJust (sY :: Sing y) -> sY
-                                SNothing -> sD))))
-          ((applySing ((singFun1 @JustSym0) SJust)) sD)
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 d)
+             (\cases
+                (SJust (sY :: Sing y)) -> sY
+                SNothing -> sD))
+          (applySing (singFun1 @JustSym0 SJust) sD)
     sFoo1 (sD :: Sing d) (sX :: Sing x)
-      = (applySing
-           ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 d) x))
-              (\ sX_0123456789876543210
-                 -> case sX_0123456789876543210 of
-                      (_ :: Sing x_0123456789876543210)
-                        -> (id
-                              @(Sing (Case_0123456789876543210 x_0123456789876543210 d x x_0123456789876543210)))
-                             (case sX_0123456789876543210 of
-                                SJust (sY :: Sing y) -> sY
-                                SNothing -> sD))))
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 d x)
+             (\cases
+                (SJust (sY :: Sing y)) -> sY
+                SNothing -> sD))
           sX
     instance SingI (Foo3Sym0 :: (~>) a ((~>) b a)) where
-      sing = (singFun2 @Foo3Sym0) sFoo3
+      sing = singFun2 @Foo3Sym0 sFoo3
     instance SingI d => SingI (Foo3Sym1 (d :: a) :: (~>) b a) where
-      sing = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 (sing @d))
+      sing = singFun1 @(Foo3Sym1 (d :: a)) (sFoo3 (sing @d))
     instance SingI1 (Foo3Sym1 :: a -> (~>) b a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 s)
+        = singFun1 @(Foo3Sym1 (d :: a)) (sFoo3 s)
     instance SingI (Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)) where
-      sing = (singFun2 @Foo2Sym0) sFoo2
+      sing = singFun2 @Foo2Sym0 sFoo2
     instance SingI d =>
              SingI (Foo2Sym1 (d :: a) :: (~>) (Maybe a) a) where
-      sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d))
+      sing = singFun1 @(Foo2Sym1 (d :: a)) (sFoo2 (sing @d))
     instance SingI1 (Foo2Sym1 :: a -> (~>) (Maybe a) a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 s)
+        = singFun1 @(Foo2Sym1 (d :: a)) (sFoo2 s)
     instance SingI (Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)) where
-      sing = (singFun2 @Foo1Sym0) sFoo1
+      sing = singFun2 @Foo1Sym0 sFoo1
     instance SingI d =>
              SingI (Foo1Sym1 (d :: a) :: (~>) (Maybe a) a) where
-      sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d))
+      sing = singFun1 @(Foo1Sym1 (d :: a)) (sFoo1 (sing @d))
     instance SingI1 (Foo1Sym1 :: a -> (~>) (Maybe a) a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 s)
+        = singFun1 @(Foo1Sym1 (d :: a)) (sFoo1 s)
diff --git a/tests/compile-and-dump/Singletons/Lambdas.golden b/tests/compile-and-dump/Singletons/Lambdas.golden
--- a/tests/compile-and-dump/Singletons/Lambdas.golden
+++ b/tests/compile-and-dump/Singletons/Lambdas.golden
@@ -30,11 +30,11 @@
     foo3 :: a -> a
     foo3 x = (\ y -> y) x
     foo4 :: a -> b -> c -> a
-    foo4 x y z = ((\ _ _ -> x) y) z
+    foo4 x y z = (\ _ _ -> x) y z
     foo5 :: a -> b -> b
     foo5 x y = (\ x -> x) y
     foo6 :: a -> b -> a
-    foo6 a b = ((\ x -> \ _ -> x) a) b
+    foo6 a b = (\ x -> \ _ -> x) a b
     foo7 :: a -> b -> b
     foo7 x y = (\ (_, b) -> b) (x, y)
     data Foo a b = Foo a b
@@ -45,713 +45,500 @@
       where
         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
                                 FooSym0 a0123456789876543210
-    type instance Apply FooSym0 a0123456789876543210 = FooSym1 a0123456789876543210
+    type instance Apply @a @((~>) b (Foo a b)) FooSym0 a0123456789876543210 = FooSym1 a0123456789876543210
     instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
     type FooSym1 :: forall a b. a -> (~>) b (Foo a b)
     data FooSym1 (a0123456789876543210 :: a) :: (~>) b (Foo a b)
       where
         FooSym1KindInference :: SameKind (Apply (FooSym1 a0123456789876543210) arg) (FooSym2 a0123456789876543210 arg) =>
                                 FooSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FooSym1 a0123456789876543210) a0123456789876543210 = Foo a0123456789876543210 a0123456789876543210
+    type instance Apply @b @(Foo a b) (FooSym1 a0123456789876543210) a0123456789876543210 = Foo a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (FooSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FooSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym1KindInference ())
     type FooSym2 :: forall a b. a -> b -> Foo a b
-    type family FooSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Foo a b where
+    type family FooSym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Foo a b where
       FooSym2 a0123456789876543210 a0123456789876543210 = Foo a0123456789876543210 a0123456789876543210
-    type family Case_0123456789876543210 arg_0123456789876543210 x t where
-      Case_0123456789876543210 arg_0123456789876543210 x (Foo a _) = a
-    type family Lambda_0123456789876543210 x arg_0123456789876543210 where
-      Lambda_0123456789876543210 x arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x arg_0123456789876543210
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 arg_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    type family Lambda_0123456789876543210Sym2 x0123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym2 x0123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 arg_01234567898765432100123456789876543210
-    type family Case_0123456789876543210 arg_0123456789876543210 x y t where
-      Case_0123456789876543210 arg_0123456789876543210 x y '(_, b) = b
-    type family Lambda_0123456789876543210 x y arg_0123456789876543210 where
-      Lambda_0123456789876543210 x y arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) y0123456789876543210 = Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    type family Case_0123456789876543210 arg_0123456789876543210 x a b t where
-      Case_0123456789876543210 arg_0123456789876543210 x a b _ = x
-    type family Lambda_0123456789876543210 x a b arg_0123456789876543210 where
-      Lambda_0123456789876543210 x a b arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x a b arg_0123456789876543210
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 a0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 a0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) a0123456789876543210 = Lambda_0123456789876543210Sym2 x0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 x0123456789876543210 a0123456789876543210 b0123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 a0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 a0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 a0123456789876543210 b0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 a0123456789876543210) b0123456789876543210 = Lambda_0123456789876543210Sym3 x0123456789876543210 a0123456789876543210 b0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 x0123456789876543210 a0123456789876543210 b0123456789876543210 arg_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym4 x0123456789876543210 a0123456789876543210 b0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 x0123456789876543210 a0123456789876543210 b0123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 a0123456789876543210 b0123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 a0123456789876543210 b0123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 x0123456789876543210 a0123456789876543210 b0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    type family Lambda_0123456789876543210Sym4 x0123456789876543210 a0123456789876543210 b0123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym4 x0123456789876543210 a0123456789876543210 b0123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 a0123456789876543210 b0123456789876543210 arg_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 a b x where
-      Lambda_0123456789876543210 a b x = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) a) b
-    data Lambda_0123456789876543210Sym0 a0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 a0123456789876543210 = Lambda_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 a0123456789876543210) arg) (Lambda_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 a0123456789876543210) b0123456789876543210 = Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210 where
-      Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210 = Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 x0123456789876543210
-    type family Lambda_0123456789876543210 x y x where
-      Lambda_0123456789876543210 x y x = x
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) y0123456789876543210 = Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 x0123456789876543210 where
-      Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 x0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 x0123456789876543210
-    type family Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210 x y z t where
-      Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210 x y z '(_,
-                                                                                       _) = x
-    type family Lambda_0123456789876543210 x y z arg_0123456789876543210 arg_0123456789876543210 where
-      Lambda_0123456789876543210 x y z arg_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210 x y z (Apply (Apply Tuple2Sym0 arg_0123456789876543210) arg_0123456789876543210)
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) y0123456789876543210 = Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 z0123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 z0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) z0123456789876543210 = Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210) arg) (Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    data Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym4KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym5 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())
-    type family Lambda_0123456789876543210Sym5 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym5 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 x y where
-      Lambda_0123456789876543210 x y = y
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: Foo a0123456789876543210 b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 x (Foo a _) = a
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: Foo a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: Foo a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 x y '(_, b) = b
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) y0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    type family Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 where
-      Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210
-    type family Case_0123456789876543210 arg_0123456789876543210 x y t where
-      Case_0123456789876543210 arg_0123456789876543210 x y _ = x
-    type family Lambda_0123456789876543210 x y arg_0123456789876543210 where
-      Lambda_0123456789876543210 x y arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 x a b _ = x
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 a0123456789876543210 b0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 a0123456789876543210 b0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 a0123456789876543210 b0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 a b x = LamCases_0123456789876543210Sym0 x a b
+    data LamCases_0123456789876543210Sym0 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) y0123456789876543210 = Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) (b0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 x y x = x
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    type family Case_0123456789876543210 arg_0123456789876543210 x a_0123456789876543210 t where
-      Case_0123456789876543210 arg_0123456789876543210 x a_0123456789876543210 _ = x
-    type family Lambda_0123456789876543210 x a_0123456789876543210 arg_0123456789876543210 where
-      Lambda_0123456789876543210 x a_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x a_0123456789876543210 arg_0123456789876543210
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) (z0123456789876543210 :: c0123456789876543210) a_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x y z _ _ = x
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) (z0123456789876543210 :: c0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 z0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 z0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 z0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 z0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 z0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    data LamCases_0123456789876543210Sym1 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) (z0123456789876543210 :: c0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
+        LamCases_0123456789876543210Sym1KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 z0123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 z0123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 z0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 z0123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 z0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 z0123456789876543210 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym1KindInference ())
+    type family LamCases_0123456789876543210Sym2 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) (z0123456789876543210 :: c0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 z0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 z0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 x y = y
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 x0123456789876543210 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym3 x0123456789876543210 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 x y where
-      Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 x y = x
-    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 x y _ = x
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 x a_0123456789876543210 _ = x
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (a_01234567898765432100123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) a_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 a_0123456789876543210 a_0123456789876543210 x y = x
+    data LamCases_0123456789876543210Sym0 (a_01234567898765432100123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) x0123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 y0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    data LamCases_0123456789876543210Sym1 (a_01234567898765432100123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210) arg) (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 y0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210) y0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 y0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210) where
+        LamCases_0123456789876543210Sym1KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    type family Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 y0123456789876543210 where
-      Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 y0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 y0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym1KindInference ())
+    type family LamCases_0123456789876543210Sym2 (a_01234567898765432100123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
     type Foo8Sym0 :: (~>) (Foo a b) a
     data Foo8Sym0 :: (~>) (Foo a b) a
       where
         Foo8Sym0KindInference :: SameKind (Apply Foo8Sym0 arg) (Foo8Sym1 arg) =>
                                  Foo8Sym0 a0123456789876543210
-    type instance Apply Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210
+    type instance Apply @(Foo a b) @a Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210
     instance SuppressUnusedWarnings Foo8Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo8Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo8Sym0KindInference ())
     type Foo8Sym1 :: Foo a b -> a
-    type family Foo8Sym1 (a0123456789876543210 :: Foo a b) :: a where
+    type family Foo8Sym1 @a @b (a0123456789876543210 :: Foo a b) :: a where
       Foo8Sym1 a0123456789876543210 = Foo8 a0123456789876543210
     type Foo7Sym0 :: (~>) a ((~>) b b)
     data Foo7Sym0 :: (~>) a ((~>) b b)
       where
         Foo7Sym0KindInference :: SameKind (Apply Foo7Sym0 arg) (Foo7Sym1 arg) =>
                                  Foo7Sym0 a0123456789876543210
-    type instance Apply Foo7Sym0 a0123456789876543210 = Foo7Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b b) Foo7Sym0 a0123456789876543210 = Foo7Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo7Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo7Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo7Sym0KindInference ())
     type Foo7Sym1 :: a -> (~>) b b
     data Foo7Sym1 (a0123456789876543210 :: a) :: (~>) b b
       where
         Foo7Sym1KindInference :: SameKind (Apply (Foo7Sym1 a0123456789876543210) arg) (Foo7Sym2 a0123456789876543210 arg) =>
                                  Foo7Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo7Sym1 a0123456789876543210) a0123456789876543210 = Foo7 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @b (Foo7Sym1 a0123456789876543210) a0123456789876543210 = Foo7 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo7Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo7Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo7Sym1KindInference ())
     type Foo7Sym2 :: a -> b -> b
-    type family Foo7Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
+    type family Foo7Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
       Foo7Sym2 a0123456789876543210 a0123456789876543210 = Foo7 a0123456789876543210 a0123456789876543210
     type Foo6Sym0 :: (~>) a ((~>) b a)
     data Foo6Sym0 :: (~>) a ((~>) b a)
       where
         Foo6Sym0KindInference :: SameKind (Apply Foo6Sym0 arg) (Foo6Sym1 arg) =>
                                  Foo6Sym0 a0123456789876543210
-    type instance Apply Foo6Sym0 a0123456789876543210 = Foo6Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b a) Foo6Sym0 a0123456789876543210 = Foo6Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo6Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo6Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo6Sym0KindInference ())
     type Foo6Sym1 :: a -> (~>) b a
     data Foo6Sym1 (a0123456789876543210 :: a) :: (~>) b a
       where
         Foo6Sym1KindInference :: SameKind (Apply (Foo6Sym1 a0123456789876543210) arg) (Foo6Sym2 a0123456789876543210 arg) =>
                                  Foo6Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo6Sym1 a0123456789876543210) a0123456789876543210 = Foo6 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @a (Foo6Sym1 a0123456789876543210) a0123456789876543210 = Foo6 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo6Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo6Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo6Sym1KindInference ())
     type Foo6Sym2 :: a -> b -> a
-    type family Foo6Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
+    type family Foo6Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
       Foo6Sym2 a0123456789876543210 a0123456789876543210 = Foo6 a0123456789876543210 a0123456789876543210
     type Foo5Sym0 :: (~>) a ((~>) b b)
     data Foo5Sym0 :: (~>) a ((~>) b b)
       where
         Foo5Sym0KindInference :: SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>
                                  Foo5Sym0 a0123456789876543210
-    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b b) Foo5Sym0 a0123456789876543210 = Foo5Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo5Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo5Sym0KindInference ())
     type Foo5Sym1 :: a -> (~>) b b
     data Foo5Sym1 (a0123456789876543210 :: a) :: (~>) b b
       where
         Foo5Sym1KindInference :: SameKind (Apply (Foo5Sym1 a0123456789876543210) arg) (Foo5Sym2 a0123456789876543210 arg) =>
                                  Foo5Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo5Sym1 a0123456789876543210) a0123456789876543210 = Foo5 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @b (Foo5Sym1 a0123456789876543210) a0123456789876543210 = Foo5 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo5Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo5Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo5Sym1KindInference ())
     type Foo5Sym2 :: a -> b -> b
-    type family Foo5Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
+    type family Foo5Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
       Foo5Sym2 a0123456789876543210 a0123456789876543210 = Foo5 a0123456789876543210 a0123456789876543210
     type Foo4Sym0 :: (~>) a ((~>) b ((~>) c a))
     data Foo4Sym0 :: (~>) a ((~>) b ((~>) c a))
       where
         Foo4Sym0KindInference :: SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>
                                  Foo4Sym0 a0123456789876543210
-    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b ((~>) c a)) Foo4Sym0 a0123456789876543210 = Foo4Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo4Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo4Sym0KindInference ())
     type Foo4Sym1 :: a -> (~>) b ((~>) c a)
     data Foo4Sym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c a)
       where
         Foo4Sym1KindInference :: SameKind (Apply (Foo4Sym1 a0123456789876543210) arg) (Foo4Sym2 a0123456789876543210 arg) =>
                                  Foo4Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo4Sym1 a0123456789876543210) a0123456789876543210 = Foo4Sym2 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @((~>) c a) (Foo4Sym1 a0123456789876543210) a0123456789876543210 = Foo4Sym2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo4Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo4Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo4Sym1KindInference ())
     type Foo4Sym2 :: a -> b -> (~>) c a
     data Foo4Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c a
       where
         Foo4Sym2KindInference :: SameKind (Apply (Foo4Sym2 a0123456789876543210 a0123456789876543210) arg) (Foo4Sym3 a0123456789876543210 a0123456789876543210 arg) =>
                                  Foo4Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo4Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = Foo4 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @c @a (Foo4Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = Foo4 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo4Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo4Sym2KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo4Sym2KindInference ())
     type Foo4Sym3 :: a -> b -> c -> a
-    type family Foo4Sym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: a where
+    type family Foo4Sym3 @a @b @c (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: a where
       Foo4Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = Foo4 a0123456789876543210 a0123456789876543210 a0123456789876543210
     type Foo3Sym0 :: (~>) a a
     data Foo3Sym0 :: (~>) a a
       where
         Foo3Sym0KindInference :: SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>
                                  Foo3Sym0 a0123456789876543210
-    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210
+    type instance Apply @a @a Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210
     instance SuppressUnusedWarnings Foo3Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo3Sym0KindInference ())
     type Foo3Sym1 :: a -> a
-    type family Foo3Sym1 (a0123456789876543210 :: a) :: a where
+    type family Foo3Sym1 @a (a0123456789876543210 :: a) :: a where
       Foo3Sym1 a0123456789876543210 = Foo3 a0123456789876543210
     type Foo2Sym0 :: (~>) a ((~>) b a)
     data Foo2Sym0 :: (~>) a ((~>) b a)
       where
         Foo2Sym0KindInference :: SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>
                                  Foo2Sym0 a0123456789876543210
-    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b a) Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo2Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo2Sym0KindInference ())
     type Foo2Sym1 :: a -> (~>) b a
     data Foo2Sym1 (a0123456789876543210 :: a) :: (~>) b a
       where
         Foo2Sym1KindInference :: SameKind (Apply (Foo2Sym1 a0123456789876543210) arg) (Foo2Sym2 a0123456789876543210 arg) =>
                                  Foo2Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @a (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo2Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo2Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo2Sym1KindInference ())
     type Foo2Sym2 :: a -> b -> a
-    type family Foo2Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
+    type family Foo2Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
       Foo2Sym2 a0123456789876543210 a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210
     type Foo1Sym0 :: (~>) a ((~>) b a)
     data Foo1Sym0 :: (~>) a ((~>) b a)
       where
         Foo1Sym0KindInference :: SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>
                                  Foo1Sym0 a0123456789876543210
-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b a) Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo1Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo1Sym0KindInference ())
     type Foo1Sym1 :: a -> (~>) b a
     data Foo1Sym1 (a0123456789876543210 :: a) :: (~>) b a
       where
         Foo1Sym1KindInference :: SameKind (Apply (Foo1Sym1 a0123456789876543210) arg) (Foo1Sym2 a0123456789876543210 arg) =>
                                  Foo1Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @a (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo1Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo1Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo1Sym1KindInference ())
     type Foo1Sym2 :: a -> b -> a
-    type family Foo1Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
+    type family Foo1Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
       Foo1Sym2 a0123456789876543210 a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210
     type Foo0Sym0 :: (~>) a ((~>) b a)
     data Foo0Sym0 :: (~>) a ((~>) b a)
       where
         Foo0Sym0KindInference :: SameKind (Apply Foo0Sym0 arg) (Foo0Sym1 arg) =>
                                  Foo0Sym0 a0123456789876543210
-    type instance Apply Foo0Sym0 a0123456789876543210 = Foo0Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b a) Foo0Sym0 a0123456789876543210 = Foo0Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo0Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo0Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo0Sym0KindInference ())
     type Foo0Sym1 :: a -> (~>) b a
     data Foo0Sym1 (a0123456789876543210 :: a) :: (~>) b a
       where
         Foo0Sym1KindInference :: SameKind (Apply (Foo0Sym1 a0123456789876543210) arg) (Foo0Sym2 a0123456789876543210 arg) =>
                                  Foo0Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo0Sym1 a0123456789876543210) a0123456789876543210 = Foo0 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @a (Foo0Sym1 a0123456789876543210) a0123456789876543210 = Foo0 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo0Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo0Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo0Sym1KindInference ())
     type Foo0Sym2 :: a -> b -> a
-    type family Foo0Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
+    type family Foo0Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
       Foo0Sym2 a0123456789876543210 a0123456789876543210 = Foo0 a0123456789876543210 a0123456789876543210
     type Foo8 :: Foo a b -> a
-    type family Foo8 (a :: Foo a b) :: a where
-      Foo8 x = Apply (Apply Lambda_0123456789876543210Sym0 x) x
+    type family Foo8 @a @b (a :: Foo a b) :: a where
+      Foo8 x = Apply (LamCases_0123456789876543210Sym0 x) x
     type Foo7 :: a -> b -> b
-    type family Foo7 (a :: a) (a :: b) :: b where
-      Foo7 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) (Apply (Apply Tuple2Sym0 x) y)
+    type family Foo7 @a @b (a :: a) (a :: b) :: b where
+      Foo7 x y = Apply (LamCases_0123456789876543210Sym0 x y) (Apply (Apply Tuple2Sym0 x) y)
     type Foo6 :: a -> b -> a
-    type family Foo6 (a :: a) (a :: b) :: a where
-      Foo6 a b = Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) a) b
+    type family Foo6 @a @b (a :: a) (a :: b) :: a where
+      Foo6 a b = Apply (Apply (LamCases_0123456789876543210Sym0 a b) a) b
     type Foo5 :: a -> b -> b
-    type family Foo5 (a :: a) (a :: b) :: b where
-      Foo5 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y
+    type family Foo5 @a @b (a :: a) (a :: b) :: b where
+      Foo5 x y = Apply (LamCases_0123456789876543210Sym0 x y) y
     type Foo4 :: a -> b -> c -> a
-    type family Foo4 (a :: a) (a :: b) (a :: c) :: a where
-      Foo4 x y z = Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) z) y) z
+    type family Foo4 @a @b @c (a :: a) (a :: b) (a :: c) :: a where
+      Foo4 x y z = Apply (Apply (LamCases_0123456789876543210Sym0 x y z) y) z
     type Foo3 :: a -> a
-    type family Foo3 (a :: a) :: a where
-      Foo3 x = Apply (Apply Lambda_0123456789876543210Sym0 x) x
+    type family Foo3 @a (a :: a) :: a where
+      Foo3 x = Apply (LamCases_0123456789876543210Sym0 x) x
     type Foo2 :: a -> b -> a
-    type family Foo2 (a :: a) (a :: b) :: a where
-      Foo2 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y
+    type family Foo2 @a @b (a :: a) (a :: b) :: a where
+      Foo2 x y = Apply (LamCases_0123456789876543210Sym0 x y) y
     type Foo1 :: a -> b -> a
-    type family Foo1 (a :: a) (a :: b) :: a where
-      Foo1 x a_0123456789876543210 = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) a_0123456789876543210) a_0123456789876543210
+    type family Foo1 @a @b (a :: a) (a :: b) :: a where
+      Foo1 x a_0123456789876543210 = Apply (LamCases_0123456789876543210Sym0 x a_0123456789876543210) a_0123456789876543210
     type Foo0 :: a -> b -> a
-    type family Foo0 (a :: a) (a :: b) :: a where
-      Foo0 a_0123456789876543210 a_0123456789876543210 = Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210
+    type family Foo0 @a @b (a :: a) (a :: b) :: a where
+      Foo0 a_0123456789876543210 a_0123456789876543210 = Apply (Apply (LamCases_0123456789876543210Sym0 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210) a_0123456789876543210
     sFoo8 ::
-      forall a b (t :: Foo a b). Sing t -> Sing (Apply Foo8Sym0 t :: a)
+      (forall (t :: Foo a b). Sing t -> Sing (Foo8 t :: a) :: Type)
     sFoo7 ::
-      forall a b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: b)
+      (forall (t :: a) (t :: b).
+       Sing t -> Sing t -> Sing (Foo7 t t :: b) :: Type)
     sFoo6 ::
-      forall a b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply Foo6Sym0 t) t :: a)
+      (forall (t :: a) (t :: b).
+       Sing t -> Sing t -> Sing (Foo6 t t :: a) :: Type)
     sFoo5 ::
-      forall a b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply Foo5Sym0 t) t :: b)
+      (forall (t :: a) (t :: b).
+       Sing t -> Sing t -> Sing (Foo5 t t :: b) :: Type)
     sFoo4 ::
-      forall a b c (t :: a) (t :: b) (t :: c). Sing t
-                                               -> Sing t
-                                                  -> Sing t
-                                                     -> Sing (Apply (Apply (Apply Foo4Sym0 t) t) t :: a)
-    sFoo3 :: forall a (t :: a). Sing t -> Sing (Apply Foo3Sym0 t :: a)
+      (forall (t :: a) (t :: b) (t :: c).
+       Sing t -> Sing t -> Sing t -> Sing (Foo4 t t t :: a) :: Type)
+    sFoo3 :: (forall (t :: a). Sing t -> Sing (Foo3 t :: a) :: Type)
     sFoo2 ::
-      forall a b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)
+      (forall (t :: a) (t :: b).
+       Sing t -> Sing t -> Sing (Foo2 t t :: a) :: Type)
     sFoo1 ::
-      forall a b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)
+      (forall (t :: a) (t :: b).
+       Sing t -> Sing t -> Sing (Foo1 t t :: a) :: Type)
     sFoo0 ::
-      forall a b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply Foo0Sym0 t) t :: a)
+      (forall (t :: a) (t :: b).
+       Sing t -> Sing t -> Sing (Foo0 t t :: a) :: Type)
     sFoo8 (sX :: Sing x)
-      = (applySing
-           ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x))
-              (\ sArg_0123456789876543210
-                 -> case sArg_0123456789876543210 of
-                      (_ :: Sing arg_0123456789876543210)
-                        -> (id
-                              @(Sing (Case_0123456789876543210 arg_0123456789876543210 x arg_0123456789876543210)))
-                             (case sArg_0123456789876543210 of SFoo (sA :: Sing a) _ -> sA))))
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 x)
+             (\cases (SFoo (sA :: Sing a) _) -> sA))
           sX
     sFoo7 (sX :: Sing x) (sY :: Sing y)
-      = (applySing
-           ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y))
-              (\ sArg_0123456789876543210
-                 -> case sArg_0123456789876543210 of
-                      (_ :: Sing arg_0123456789876543210)
-                        -> (id
-                              @(Sing (Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210)))
-                             (case sArg_0123456789876543210 of
-                                STuple2 _ (sB :: Sing b) -> sB))))
-          ((applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX)) sY)
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 x y)
+             (\cases (STuple2 _ (sB :: Sing b)) -> sB))
+          (applySing (applySing (singFun2 @Tuple2Sym0 STuple2) sX) sY)
     sFoo6 (sA :: Sing a) (sB :: Sing b)
-      = (applySing
-           ((applySing
-               ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 a) b))
-                  (\ sX
-                     -> case sX of
-                          (_ :: Sing x)
-                            -> (singFun1
-                                  @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) a) b))
-                                 (\ sArg_0123456789876543210
-                                    -> case sArg_0123456789876543210 of
-                                         (_ :: Sing arg_0123456789876543210)
-                                           -> (id
-                                                 @(Sing (Case_0123456789876543210 arg_0123456789876543210 x a b arg_0123456789876543210)))
-                                                (case sArg_0123456789876543210 of _ -> sX)))))
-              sA))
+      = applySing
+          (applySing
+             (singFun1
+                @(LamCases_0123456789876543210Sym0 a b)
+                (\cases
+                   (sX :: Sing x)
+                     -> singFun1
+                          @(LamCases_0123456789876543210Sym0 x a b) (\cases _ -> sX)))
+             sA)
           sB
     sFoo5 (sX :: Sing x) (sY :: Sing y)
-      = (applySing
-           ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y))
-              (\ sX -> case sX of (_ :: Sing x) -> sX)))
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 x y)
+             (\cases (sX :: Sing x) -> sX))
           sY
     sFoo4 (sX :: Sing x) (sY :: Sing y) (sZ :: Sing z)
-      = (applySing
-           ((applySing
-               ((singFun2
-                   @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) z))
-                  (\ sArg_0123456789876543210 sArg_0123456789876543210
-                     -> case ((,) sArg_0123456789876543210) sArg_0123456789876543210 of
-                          (,) (_ :: Sing arg_0123456789876543210)
-                              (_ :: Sing arg_0123456789876543210)
-                            -> (id
-                                  @(Sing (Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210 x y z (Apply (Apply Tuple2Sym0 arg_0123456789876543210) arg_0123456789876543210))))
-                                 (case
-                                      (applySing
-                                         ((applySing ((singFun2 @Tuple2Sym0) STuple2))
-                                            sArg_0123456789876543210))
-                                        sArg_0123456789876543210
-                                  of
-                                    STuple2 _ _ -> sX))))
-              sY))
+      = applySing
+          (applySing
+             (singFun2
+                @(LamCases_0123456789876543210Sym0 x y z) (\cases _ _ -> sX))
+             sY)
           sZ
     sFoo3 (sX :: Sing x)
-      = (applySing
-           ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x))
-              (\ sY -> case sY of (_ :: Sing y) -> sY)))
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 x)
+             (\cases (sY :: Sing y) -> sY))
           sX
     sFoo2 (sX :: Sing x) (sY :: Sing y)
-      = (applySing
-           ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y))
-              (\ sArg_0123456789876543210
-                 -> case sArg_0123456789876543210 of
-                      (_ :: Sing arg_0123456789876543210)
-                        -> (id
-                              @(Sing (Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210)))
-                             (case sArg_0123456789876543210 of _ -> sX))))
+      = applySing
+          (singFun1 @(LamCases_0123456789876543210Sym0 x y) (\cases _ -> sX))
           sY
     sFoo1
       (sX :: Sing x)
       (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing
-           ((singFun1
-               @(Apply (Apply Lambda_0123456789876543210Sym0 x) a_0123456789876543210))
-              (\ sArg_0123456789876543210
-                 -> case sArg_0123456789876543210 of
-                      (_ :: Sing arg_0123456789876543210)
-                        -> (id
-                              @(Sing (Case_0123456789876543210 arg_0123456789876543210 x a_0123456789876543210 arg_0123456789876543210)))
-                             (case sArg_0123456789876543210 of _ -> sX))))
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 x a_0123456789876543210)
+             (\cases _ -> sX))
           sA_0123456789876543210
     sFoo0
       (sA_0123456789876543210 :: Sing a_0123456789876543210)
       (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing
-           ((applySing
-               ((singFun2
-                   @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210))
-                  (\ sX sY
-                     -> case ((,) sX) sY of (,) (_ :: Sing x) (_ :: Sing y) -> sX)))
-              sA_0123456789876543210))
+      = applySing
+          (applySing
+             (singFun2
+                @(LamCases_0123456789876543210Sym0 a_0123456789876543210 a_0123456789876543210)
+                (\cases (sX :: Sing x) (sY :: Sing y) -> sX))
+             sA_0123456789876543210)
           sA_0123456789876543210
     instance SingI (Foo8Sym0 :: (~>) (Foo a b) a) where
-      sing = (singFun1 @Foo8Sym0) sFoo8
+      sing = singFun1 @Foo8Sym0 sFoo8
     instance SingI (Foo7Sym0 :: (~>) a ((~>) b b)) where
-      sing = (singFun2 @Foo7Sym0) sFoo7
+      sing = singFun2 @Foo7Sym0 sFoo7
     instance SingI d => SingI (Foo7Sym1 (d :: a) :: (~>) b b) where
-      sing = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 (sing @d))
+      sing = singFun1 @(Foo7Sym1 (d :: a)) (sFoo7 (sing @d))
     instance SingI1 (Foo7Sym1 :: a -> (~>) b b) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 s)
+        = singFun1 @(Foo7Sym1 (d :: a)) (sFoo7 s)
     instance SingI (Foo6Sym0 :: (~>) a ((~>) b a)) where
-      sing = (singFun2 @Foo6Sym0) sFoo6
+      sing = singFun2 @Foo6Sym0 sFoo6
     instance SingI d => SingI (Foo6Sym1 (d :: a) :: (~>) b a) where
-      sing = (singFun1 @(Foo6Sym1 (d :: a))) (sFoo6 (sing @d))
+      sing = singFun1 @(Foo6Sym1 (d :: a)) (sFoo6 (sing @d))
     instance SingI1 (Foo6Sym1 :: a -> (~>) b a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo6Sym1 (d :: a))) (sFoo6 s)
+        = singFun1 @(Foo6Sym1 (d :: a)) (sFoo6 s)
     instance SingI (Foo5Sym0 :: (~>) a ((~>) b b)) where
-      sing = (singFun2 @Foo5Sym0) sFoo5
+      sing = singFun2 @Foo5Sym0 sFoo5
     instance SingI d => SingI (Foo5Sym1 (d :: a) :: (~>) b b) where
-      sing = (singFun1 @(Foo5Sym1 (d :: a))) (sFoo5 (sing @d))
+      sing = singFun1 @(Foo5Sym1 (d :: a)) (sFoo5 (sing @d))
     instance SingI1 (Foo5Sym1 :: a -> (~>) b b) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo5Sym1 (d :: a))) (sFoo5 s)
+        = singFun1 @(Foo5Sym1 (d :: a)) (sFoo5 s)
     instance SingI (Foo4Sym0 :: (~>) a ((~>) b ((~>) c a))) where
-      sing = (singFun3 @Foo4Sym0) sFoo4
+      sing = singFun3 @Foo4Sym0 sFoo4
     instance SingI d =>
              SingI (Foo4Sym1 (d :: a) :: (~>) b ((~>) c a)) where
-      sing = (singFun2 @(Foo4Sym1 (d :: a))) (sFoo4 (sing @d))
+      sing = singFun2 @(Foo4Sym1 (d :: a)) (sFoo4 (sing @d))
     instance SingI1 (Foo4Sym1 :: a -> (~>) b ((~>) c a)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun2 @(Foo4Sym1 (d :: a))) (sFoo4 s)
+        = singFun2 @(Foo4Sym1 (d :: a)) (sFoo4 s)
     instance (SingI d, SingI d) =>
              SingI (Foo4Sym2 (d :: a) (d :: b) :: (~>) c a) where
       sing
-        = (singFun1 @(Foo4Sym2 (d :: a) (d :: b)))
-            ((sFoo4 (sing @d)) (sing @d))
+        = singFun1
+            @(Foo4Sym2 (d :: a) (d :: b)) (sFoo4 (sing @d) (sing @d))
     instance SingI d =>
              SingI1 (Foo4Sym2 (d :: a) :: b -> (~>) c a) where
       liftSing (s :: Sing (d :: b))
-        = (singFun1 @(Foo4Sym2 (d :: a) (d :: b))) ((sFoo4 (sing @d)) s)
+        = singFun1 @(Foo4Sym2 (d :: a) (d :: b)) (sFoo4 (sing @d) s)
     instance SingI2 (Foo4Sym2 :: a -> b -> (~>) c a) where
       liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
-        = (singFun1 @(Foo4Sym2 (d :: a) (d :: b))) ((sFoo4 s) s)
+        = singFun1 @(Foo4Sym2 (d :: a) (d :: b)) (sFoo4 s s)
     instance SingI (Foo3Sym0 :: (~>) a a) where
-      sing = (singFun1 @Foo3Sym0) sFoo3
+      sing = singFun1 @Foo3Sym0 sFoo3
     instance SingI (Foo2Sym0 :: (~>) a ((~>) b a)) where
-      sing = (singFun2 @Foo2Sym0) sFoo2
+      sing = singFun2 @Foo2Sym0 sFoo2
     instance SingI d => SingI (Foo2Sym1 (d :: a) :: (~>) b a) where
-      sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d))
+      sing = singFun1 @(Foo2Sym1 (d :: a)) (sFoo2 (sing @d))
     instance SingI1 (Foo2Sym1 :: a -> (~>) b a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 s)
+        = singFun1 @(Foo2Sym1 (d :: a)) (sFoo2 s)
     instance SingI (Foo1Sym0 :: (~>) a ((~>) b a)) where
-      sing = (singFun2 @Foo1Sym0) sFoo1
+      sing = singFun2 @Foo1Sym0 sFoo1
     instance SingI d => SingI (Foo1Sym1 (d :: a) :: (~>) b a) where
-      sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d))
+      sing = singFun1 @(Foo1Sym1 (d :: a)) (sFoo1 (sing @d))
     instance SingI1 (Foo1Sym1 :: a -> (~>) b a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 s)
+        = singFun1 @(Foo1Sym1 (d :: a)) (sFoo1 s)
     instance SingI (Foo0Sym0 :: (~>) a ((~>) b a)) where
-      sing = (singFun2 @Foo0Sym0) sFoo0
+      sing = singFun2 @Foo0Sym0 sFoo0
     instance SingI d => SingI (Foo0Sym1 (d :: a) :: (~>) b a) where
-      sing = (singFun1 @(Foo0Sym1 (d :: a))) (sFoo0 (sing @d))
+      sing = singFun1 @(Foo0Sym1 (d :: a)) (sFoo0 (sing @d))
     instance SingI1 (Foo0Sym1 :: a -> (~>) b a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo0Sym1 (d :: a))) (sFoo0 s)
+        = singFun1 @(Foo0Sym1 (d :: a)) (sFoo0 s)
     data SFoo :: forall a b. Foo a b -> Type
       where
         SFoo :: forall a b (n :: a) (n :: b).
@@ -759,21 +546,21 @@
     type instance Sing @(Foo a b) = SFoo
     instance (SingKind a, SingKind b) => SingKind (Foo a b) where
       type Demote (Foo a b) = Foo (Demote a) (Demote b)
-      fromSing (SFoo b b) = (Foo (fromSing b)) (fromSing b)
+      fromSing (SFoo b b) = Foo (fromSing b) (fromSing b)
       toSing (Foo (b :: Demote a) (b :: Demote b))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SFoo c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SFoo c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
     instance (SingI n, SingI n) => SingI (Foo (n :: a) (n :: b)) where
-      sing = (SFoo sing) sing
+      sing = SFoo sing sing
     instance SingI n => SingI1 (Foo (n :: a)) where
       liftSing = SFoo sing
     instance SingI2 Foo where
       liftSing2 = SFoo
     instance SingI (FooSym0 :: (~>) a ((~>) b (Foo a b))) where
-      sing = (singFun2 @FooSym0) SFoo
+      sing = singFun2 @FooSym0 SFoo
     instance SingI d =>
              SingI (FooSym1 (d :: a) :: (~>) b (Foo a b)) where
-      sing = (singFun1 @(FooSym1 (d :: a))) (SFoo (sing @d))
+      sing = singFun1 @(FooSym1 (d :: a)) (SFoo (sing @d))
     instance SingI1 (FooSym1 :: a -> (~>) b (Foo a b)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(FooSym1 (d :: a))) (SFoo s)
+        = singFun1 @(FooSym1 (d :: a)) (SFoo s)
diff --git a/tests/compile-and-dump/Singletons/LambdasComprehensive.golden b/tests/compile-and-dump/Singletons/LambdasComprehensive.golden
--- a/tests/compile-and-dump/Singletons/LambdasComprehensive.golden
+++ b/tests/compile-and-dump/Singletons/LambdasComprehensive.golden
@@ -8,22 +8,21 @@
   ======>
     foo :: [Nat]
     foo
-      = (map (\ x -> ((either_ pred) Succ) x))
-          [Left Zero, Right (Succ Zero)]
+      = map (\ x -> either_ pred Succ x) [Left Zero, Right (Succ Zero)]
     bar :: [Nat]
-    bar = (map ((either_ pred) Succ)) [Left Zero, Right (Succ Zero)]
-    type family Lambda_0123456789876543210 x where
-      Lambda_0123456789876543210 x = Apply (Apply (Apply Either_Sym0 PredSym0) SuccSym0) x
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
+    bar = map (either_ pred Succ) [Left Zero, Right (Succ Zero)]
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x = Apply (Apply (Apply Either_Sym0 PredSym0) SuccSym0) x
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    type family Lambda_0123456789876543210Sym1 x0123456789876543210 where
-      Lambda_0123456789876543210Sym1 x0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
     type BarSym0 :: [Nat]
     type family BarSym0 :: [Nat] where
       BarSym0 = Bar
@@ -35,42 +34,50 @@
       Bar = Apply (Apply MapSym0 (Apply (Apply Either_Sym0 PredSym0) SuccSym0)) (Apply (Apply (:@#@$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) NilSym0))
     type Foo :: [Nat]
     type family Foo :: [Nat] where
-      Foo = Apply (Apply MapSym0 Lambda_0123456789876543210Sym0) (Apply (Apply (:@#@$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) NilSym0))
-    sBar :: Sing (BarSym0 :: [Nat])
-    sFoo :: Sing (FooSym0 :: [Nat])
+      Foo = Apply (Apply MapSym0 LamCases_0123456789876543210Sym0) (Apply (Apply (:@#@$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) NilSym0))
+    sBar :: (Sing (Bar :: [Nat]) :: Type)
+    sFoo :: (Sing (Foo :: [Nat]) :: Type)
     sBar
-      = (applySing
-           ((applySing ((singFun2 @MapSym0) sMap))
-              ((applySing
-                  ((applySing ((singFun3 @Either_Sym0) sEither_))
-                     ((singFun1 @PredSym0) sPred)))
-                 ((singFun1 @SuccSym0) SSucc))))
-          ((applySing
-              ((applySing ((singFun2 @(:@#@$)) SCons))
-                 ((applySing ((singFun1 @LeftSym0) SLeft)) SZero)))
-             ((applySing
-                 ((applySing ((singFun2 @(:@#@$)) SCons))
-                    ((applySing ((singFun1 @RightSym0) SRight))
-                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))
+      = applySing
+          (applySing
+             (singFun2 @MapSym0 sMap)
+             (applySing
+                (applySing
+                   (singFun3 @Either_Sym0 sEither_) (singFun1 @PredSym0 sPred))
+                (singFun1 @SuccSym0 SSucc)))
+          (applySing
+             (applySing
+                (singFun2 @(:@#@$) SCons)
+                (applySing (singFun1 @LeftSym0 SLeft) SZero))
+             (applySing
+                (applySing
+                   (singFun2 @(:@#@$) SCons)
+                   (applySing
+                      (singFun1 @RightSym0 SRight)
+                      (applySing (singFun1 @SuccSym0 SSucc) SZero)))
                 SNil))
     sFoo
-      = (applySing
-           ((applySing ((singFun2 @MapSym0) sMap))
-              ((singFun1 @Lambda_0123456789876543210Sym0)
-                 (\ sX
-                    -> case sX of
-                         (_ :: Sing x)
-                           -> (applySing
-                                 ((applySing
-                                     ((applySing ((singFun3 @Either_Sym0) sEither_))
-                                        ((singFun1 @PredSym0) sPred)))
-                                    ((singFun1 @SuccSym0) SSucc)))
-                                sX))))
-          ((applySing
-              ((applySing ((singFun2 @(:@#@$)) SCons))
-                 ((applySing ((singFun1 @LeftSym0) SLeft)) SZero)))
-             ((applySing
-                 ((applySing ((singFun2 @(:@#@$)) SCons))
-                    ((applySing ((singFun1 @RightSym0) SRight))
-                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))
+      = applySing
+          (applySing
+             (singFun2 @MapSym0 sMap)
+             (singFun1
+                @LamCases_0123456789876543210Sym0
+                (\cases
+                   (sX :: Sing x)
+                     -> applySing
+                          (applySing
+                             (applySing
+                                (singFun3 @Either_Sym0 sEither_) (singFun1 @PredSym0 sPred))
+                             (singFun1 @SuccSym0 SSucc))
+                          sX)))
+          (applySing
+             (applySing
+                (singFun2 @(:@#@$) SCons)
+                (applySing (singFun1 @LeftSym0 SLeft) SZero))
+             (applySing
+                (applySing
+                   (singFun2 @(:@#@$) SCons)
+                   (applySing
+                      (singFun1 @RightSym0 SRight)
+                      (applySing (singFun1 @SuccSym0 SSucc) SZero)))
                 SNil))
diff --git a/tests/compile-and-dump/Singletons/LetStatements.golden b/tests/compile-and-dump/Singletons/LetStatements.golden
--- a/tests/compile-and-dump/Singletons/LetStatements.golden
+++ b/tests/compile-and-dump/Singletons/LetStatements.golden
@@ -189,356 +189,206 @@
     foo13_ y = y
     foo14 :: Nat -> (Nat, Nat)
     foo14 x = let (y, z) = (Succ x, x) in (z, y)
-    type family Case_0123456789876543210 x t where
-      Case_0123456789876543210 x '(_,
-                                   y_0123456789876543210) = y_0123456789876543210
-    type family Case_0123456789876543210 x t where
-      Case_0123456789876543210 x '(y_0123456789876543210,
-                                   _) = y_0123456789876543210
-    data Let0123456789876543210ZSym0 x0123456789876543210
-      where
-        Let0123456789876543210ZSym0KindInference :: SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>
-                                                    Let0123456789876543210ZSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())
-    type family Let0123456789876543210ZSym1 x0123456789876543210 where
-      Let0123456789876543210ZSym1 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
-    data Let0123456789876543210YSym0 x0123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: Nat) a_0123456789876543210 where
+      LamCases_0123456789876543210 x '(_,
+                                       y_0123456789876543210) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: Nat) a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210YSym0KindInference :: SameKind (Apply Let0123456789876543210YSym0 arg) (Let0123456789876543210YSym1 arg) =>
-                                                    Let0123456789876543210YSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210YSym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210YSym0KindInference) ())
-    type family Let0123456789876543210YSym1 x0123456789876543210 where
-      Let0123456789876543210YSym1 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210
-    data Let0123456789876543210X_0123456789876543210Sym0 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: Nat) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: Nat) a_0123456789876543210 where
+      LamCases_0123456789876543210 x '(y_0123456789876543210,
+                                       _) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: Nat) a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210X_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210X_0123456789876543210Sym0 arg) (Let0123456789876543210X_0123456789876543210Sym1 arg) =>
-                                                                        Let0123456789876543210X_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Let0123456789876543210X_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210X_0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210X_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd
-            (((,) Let0123456789876543210X_0123456789876543210Sym0KindInference)
-               ())
-    type family Let0123456789876543210X_0123456789876543210Sym1 x0123456789876543210 where
-      Let0123456789876543210X_0123456789876543210Sym1 x0123456789876543210 = Let0123456789876543210X_0123456789876543210 x0123456789876543210
-    type family Let0123456789876543210Z x where
-      Let0123456789876543210Z x = Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x)
-    type family Let0123456789876543210Y x where
-      Let0123456789876543210Y x = Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x)
-    type family Let0123456789876543210X_0123456789876543210 x where
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: Nat) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type family Let0123456789876543210ZSym0 (x0123456789876543210 :: Nat) where
+      Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
+    type family Let0123456789876543210YSym0 (x0123456789876543210 :: Nat) where
+      Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210
+    type family Let0123456789876543210X_0123456789876543210Sym0 (x0123456789876543210 :: Nat) where
+      Let0123456789876543210X_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210X_0123456789876543210 x0123456789876543210
+    type family Let0123456789876543210Z (x0123456789876543210 :: Nat) where
+      Let0123456789876543210Z x = Apply (LamCases_0123456789876543210Sym0 x) (Let0123456789876543210X_0123456789876543210Sym0 x)
+    type family Let0123456789876543210Y (x0123456789876543210 :: Nat) where
+      Let0123456789876543210Y x = Apply (LamCases_0123456789876543210Sym0 x) (Let0123456789876543210X_0123456789876543210Sym0 x)
+    type family Let0123456789876543210X_0123456789876543210 (x0123456789876543210 :: Nat) where
       Let0123456789876543210X_0123456789876543210 x = Apply (Apply Tuple2Sym0 (Apply SuccSym0 x)) x
-    data Let0123456789876543210BarSym0 x0123456789876543210
-      where
-        Let0123456789876543210BarSym0KindInference :: SameKind (Apply Let0123456789876543210BarSym0 arg) (Let0123456789876543210BarSym1 arg) =>
-                                                      Let0123456789876543210BarSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210BarSym0 x0123456789876543210 = Let0123456789876543210Bar x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210BarSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210BarSym0KindInference) ())
-    type family Let0123456789876543210BarSym1 x0123456789876543210 :: a0123456789876543210 where
-      Let0123456789876543210BarSym1 x0123456789876543210 = Let0123456789876543210Bar x0123456789876543210
-    type family Let0123456789876543210Bar x :: a where
-      Let0123456789876543210Bar x = x
-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210
-      where
-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: SameKind (Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>
-                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210
-    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210
-    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) where
-      suppressUnusedWarnings
-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###)) ())
-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 :: (~>) Nat ((~>) Nat Nat)
+    type family Let0123456789876543210BarSym0 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) :: a0123456789876543210 where
+      Let0123456789876543210BarSym0 a0123456789876543210 x0123456789876543210 = Let0123456789876543210Bar a0123456789876543210 x0123456789876543210
+    type family Let0123456789876543210Bar a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) :: a0123456789876543210 where
+      Let0123456789876543210Bar a x = x
+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) (x0123456789876543210 :: Nat) :: (~>) Nat ((~>) Nat Nat)
       where
-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 arg) =>
-                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210
-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) where
+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 arg) =>
+                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @((~>) Nat Nat) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###)) ())
-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (a0123456789876543210 :: Nat) :: (~>) Nat Nat
+        = snd ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) ())
+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) (x0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 arg) =>
-                                               (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) where
+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 arg) =>
+                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###)) ())
-    type family (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
-      (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
-    type family (<<<%%%%%%%%%%%%%%%%%%%%) x (a :: Nat) (a :: Nat) :: Nat where
+        = snd ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) ())
+    type family (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) (x0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
+      (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
+    type family (<<<%%%%%%%%%%%%%%%%%%%%) (x0123456789876543210 :: Nat) (a :: Nat) (a :: Nat) :: Nat where
       (<<<%%%%%%%%%%%%%%%%%%%%) x 'Zero m = m
-      (<<<%%%%%%%%%%%%%%%%%%%%) x ('Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) n) x)
-    data Let0123456789876543210ZSym0 x0123456789876543210
-      where
-        Let0123456789876543210ZSym0KindInference :: SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>
-                                                    Let0123456789876543210ZSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())
-    type family Let0123456789876543210ZSym1 x0123456789876543210 :: Nat where
-      Let0123456789876543210ZSym1 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210
-      where
-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: SameKind (Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>
-                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210
-    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210
-    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) where
-      suppressUnusedWarnings
-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###)) ())
-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 :: (~>) Nat ((~>) Nat Nat)
+      (<<<%%%%%%%%%%%%%%%%%%%%) x ('Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) n) x)
+    type family Let0123456789876543210ZSym0 (x0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) (x0123456789876543210 :: Nat) :: (~>) Nat ((~>) Nat Nat)
       where
-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 arg) =>
-                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210
-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) where
+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 arg) =>
+                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @((~>) Nat Nat) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###)) ())
-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (a0123456789876543210 :: Nat) :: (~>) Nat Nat
+        = snd ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) ())
+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) (x0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 arg) =>
-                                               (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) where
+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 arg) =>
+                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###)) ())
-    type family (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
-      (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
-    type family Let0123456789876543210Z x :: Nat where
+        = snd ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) ())
+    type family (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) (x0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
+      (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
+    type family Let0123456789876543210Z (x0123456789876543210 :: Nat) :: Nat where
       Let0123456789876543210Z x = x
-    type family (<<<%%%%%%%%%%%%%%%%%%%%) x (a :: Nat) (a :: Nat) :: Nat where
+    type family (<<<%%%%%%%%%%%%%%%%%%%%) (x0123456789876543210 :: Nat) (a :: Nat) (a :: Nat) :: Nat where
       (<<<%%%%%%%%%%%%%%%%%%%%) x 'Zero m = m
-      (<<<%%%%%%%%%%%%%%%%%%%%) x ('Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) n) m)
-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210
-      where
-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: SameKind (Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>
-                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210
-    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210
-    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) where
-      suppressUnusedWarnings
-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###)) ())
-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 :: (~>) Nat ((~>) Nat Nat)
+      (<<<%%%%%%%%%%%%%%%%%%%%) x ('Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) n) m)
+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) (x0123456789876543210 :: Nat) :: (~>) Nat ((~>) Nat Nat)
       where
-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 arg) =>
-                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210
-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) where
+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 arg) =>
+                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @((~>) Nat Nat) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###)) ())
-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (a0123456789876543210 :: Nat) :: (~>) Nat Nat
+        = snd ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) ())
+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) (x0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 arg) =>
-                                               (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) where
+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 arg) =>
+                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###)) ())
-    type family (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
-      (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
-    type family (<<<%%%%%%%%%%%%%%%%%%%%) x (a :: Nat) (a :: Nat) :: Nat where
+        = snd ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) ())
+    type family (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) (x0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
+      (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210
+    type family (<<<%%%%%%%%%%%%%%%%%%%%) (x0123456789876543210 :: Nat) (a :: Nat) (a :: Nat) :: Nat where
       (<<<%%%%%%%%%%%%%%%%%%%%) x 'Zero m = m
-      (<<<%%%%%%%%%%%%%%%%%%%%) x ('Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) n) m)
-    type family Lambda_0123456789876543210 a_0123456789876543210 x x where
-      Lambda_0123456789876543210 a_0123456789876543210 x x = x
-    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) x0123456789876543210 = Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 x0123456789876543210 x0123456789876543210 where
-      Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 x0123456789876543210 x0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 x0123456789876543210
-    data Let0123456789876543210ZSym0 x0123456789876543210
-      where
-        Let0123456789876543210ZSym0KindInference :: SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>
-                                                    Let0123456789876543210ZSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210ZSym1 x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())
-    data Let0123456789876543210ZSym1 x0123456789876543210 :: (~>) Nat Nat
-      where
-        Let0123456789876543210ZSym1KindInference :: SameKind (Apply (Let0123456789876543210ZSym1 x0123456789876543210) arg) (Let0123456789876543210ZSym2 x0123456789876543210 arg) =>
-                                                    Let0123456789876543210ZSym1 x0123456789876543210 a0123456789876543210
-    type instance Apply (Let0123456789876543210ZSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210Z x0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210ZSym1 x0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210ZSym1KindInference) ())
-    type family Let0123456789876543210ZSym2 x0123456789876543210 (a0123456789876543210 :: Nat) :: Nat where
-      Let0123456789876543210ZSym2 x0123456789876543210 a0123456789876543210 = Let0123456789876543210Z x0123456789876543210 a0123456789876543210
-    type family Let0123456789876543210Z x (a :: Nat) :: Nat where
-      Let0123456789876543210Z x a_0123456789876543210 = Apply (Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) x) a_0123456789876543210
-    type family Lambda_0123456789876543210 x x where
-      Lambda_0123456789876543210 x x = x
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 x0123456789876543210
+      (<<<%%%%%%%%%%%%%%%%%%%%) x ('Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) n) m)
+    type family LamCases_0123456789876543210 (a_01234567898765432100123456789876543210 :: Nat) (x0123456789876543210 :: Nat) a_0123456789876543210 where
+      LamCases_0123456789876543210 a_0123456789876543210 x x = x
+    data LamCases_0123456789876543210Sym0 (a_01234567898765432100123456789876543210 :: Nat) (x0123456789876543210 :: Nat) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    type family Lambda_0123456789876543210Sym2 x0123456789876543210 x0123456789876543210 where
-      Lambda_0123456789876543210Sym2 x0123456789876543210 x0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 x0123456789876543210
-    data Let0123456789876543210ZSym0 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (a_01234567898765432100123456789876543210 :: Nat) (x0123456789876543210 :: Nat) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    data Let0123456789876543210ZSym0 (x0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
-        Let0123456789876543210ZSym0KindInference :: SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>
-                                                    Let0123456789876543210ZSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where
+        Let0123456789876543210ZSym0KindInference :: SameKind (Apply (Let0123456789876543210ZSym0 x0123456789876543210) arg) (Let0123456789876543210ZSym1 x0123456789876543210 arg) =>
+                                                    Let0123456789876543210ZSym0 x0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat (Let0123456789876543210ZSym0 x0123456789876543210) a0123456789876543210 = Let0123456789876543210Z x0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Let0123456789876543210ZSym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())
-    type family Let0123456789876543210ZSym1 x0123456789876543210 :: Nat where
-      Let0123456789876543210ZSym1 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
-    type family Let0123456789876543210Z x :: Nat where
-      Let0123456789876543210Z x = Apply (Apply Lambda_0123456789876543210Sym0 x) ZeroSym0
-    data Let0123456789876543210XSym0 x0123456789876543210
+        = snd ((,) Let0123456789876543210ZSym0KindInference ())
+    type family Let0123456789876543210ZSym1 (x0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210ZSym1 x0123456789876543210 a0123456789876543210 = Let0123456789876543210Z x0123456789876543210 a0123456789876543210
+    type family Let0123456789876543210Z (x0123456789876543210 :: Nat) (a :: Nat) :: Nat where
+      Let0123456789876543210Z x a_0123456789876543210 = Apply (LamCases_0123456789876543210Sym0 a_0123456789876543210 x) a_0123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: Nat) a_0123456789876543210 where
+      LamCases_0123456789876543210 x x = x
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: Nat) a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210XSym0KindInference :: SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>
-                                                    Let0123456789876543210XSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210XSym0 x0123456789876543210 = Let0123456789876543210X x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210XSym0KindInference) ())
-    type family Let0123456789876543210XSym1 x0123456789876543210 :: Nat where
-      Let0123456789876543210XSym1 x0123456789876543210 = Let0123456789876543210X x0123456789876543210
-    type family Let0123456789876543210X x :: Nat where
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: Nat) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type family Let0123456789876543210ZSym0 (x0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
+    type family Let0123456789876543210Z (x0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210Z x = Apply (LamCases_0123456789876543210Sym0 x) ZeroSym0
+    type family Let0123456789876543210XSym0 (x0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210XSym0 x0123456789876543210 = Let0123456789876543210X x0123456789876543210
+    type family Let0123456789876543210X (x0123456789876543210 :: Nat) :: Nat where
       Let0123456789876543210X x = ZeroSym0
-    data Let0123456789876543210FSym0 x0123456789876543210
-      where
-        Let0123456789876543210FSym0KindInference :: SameKind (Apply Let0123456789876543210FSym0 arg) (Let0123456789876543210FSym1 arg) =>
-                                                    Let0123456789876543210FSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210FSym0 x0123456789876543210 = Let0123456789876543210FSym1 x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210FSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210FSym0KindInference) ())
-    data Let0123456789876543210FSym1 x0123456789876543210 :: (~>) Nat Nat
+    data Let0123456789876543210FSym0 (x0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
-        Let0123456789876543210FSym1KindInference :: SameKind (Apply (Let0123456789876543210FSym1 x0123456789876543210) arg) (Let0123456789876543210FSym2 x0123456789876543210 arg) =>
-                                                    Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210
-    type instance Apply (Let0123456789876543210FSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210FSym1 x0123456789876543210) where
+        Let0123456789876543210FSym0KindInference :: SameKind (Apply (Let0123456789876543210FSym0 x0123456789876543210) arg) (Let0123456789876543210FSym1 x0123456789876543210 arg) =>
+                                                    Let0123456789876543210FSym0 x0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat (Let0123456789876543210FSym0 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Let0123456789876543210FSym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210FSym1KindInference) ())
-    type family Let0123456789876543210FSym2 x0123456789876543210 (a0123456789876543210 :: Nat) :: Nat where
-      Let0123456789876543210FSym2 x0123456789876543210 a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
-    type family Let0123456789876543210F x (a :: Nat) :: Nat where
+        = snd ((,) Let0123456789876543210FSym0KindInference ())
+    type family Let0123456789876543210FSym1 (x0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
+    type family Let0123456789876543210F (x0123456789876543210 :: Nat) (a :: Nat) :: Nat where
       Let0123456789876543210F x y = Apply SuccSym0 y
-    data Let0123456789876543210ZSym0 x0123456789876543210
-      where
-        Let0123456789876543210ZSym0KindInference :: SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>
-                                                    Let0123456789876543210ZSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())
-    type family Let0123456789876543210ZSym1 x0123456789876543210 :: Nat where
-      Let0123456789876543210ZSym1 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
-    type family Let0123456789876543210Z x :: Nat where
-      Let0123456789876543210Z x = Apply (Let0123456789876543210FSym1 x) x
-    data Let0123456789876543210ZSym0 y0123456789876543210
-      where
-        Let0123456789876543210ZSym0KindInference :: SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>
-                                                    Let0123456789876543210ZSym0 y0123456789876543210
-    type instance Apply Let0123456789876543210ZSym0 y0123456789876543210 = Let0123456789876543210ZSym1 y0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())
-    data Let0123456789876543210ZSym1 y0123456789876543210 x0123456789876543210
-      where
-        Let0123456789876543210ZSym1KindInference :: SameKind (Apply (Let0123456789876543210ZSym1 y0123456789876543210) arg) (Let0123456789876543210ZSym2 y0123456789876543210 arg) =>
-                                                    Let0123456789876543210ZSym1 y0123456789876543210 x0123456789876543210
-    type instance Apply (Let0123456789876543210ZSym1 y0123456789876543210) x0123456789876543210 = Let0123456789876543210Z y0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210ZSym1 y0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210ZSym1KindInference) ())
-    type family Let0123456789876543210ZSym2 y0123456789876543210 x0123456789876543210 :: Nat where
-      Let0123456789876543210ZSym2 y0123456789876543210 x0123456789876543210 = Let0123456789876543210Z y0123456789876543210 x0123456789876543210
-    type family Let0123456789876543210Z y x :: Nat where
+    type family Let0123456789876543210ZSym0 (x0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210
+    type family Let0123456789876543210Z (x0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210Z x = Apply (Let0123456789876543210FSym0 x) x
+    type family Let0123456789876543210ZSym0 (y0123456789876543210 :: Nat) (x0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210ZSym0 y0123456789876543210 x0123456789876543210 = Let0123456789876543210Z y0123456789876543210 x0123456789876543210
+    type family Let0123456789876543210Z (y0123456789876543210 :: Nat) (x0123456789876543210 :: Nat) :: Nat where
       Let0123456789876543210Z y x = Apply SuccSym0 y
-    data Let0123456789876543210FSym0 x0123456789876543210
-      where
-        Let0123456789876543210FSym0KindInference :: SameKind (Apply Let0123456789876543210FSym0 arg) (Let0123456789876543210FSym1 arg) =>
-                                                    Let0123456789876543210FSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210FSym0 x0123456789876543210 = Let0123456789876543210FSym1 x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210FSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210FSym0KindInference) ())
-    data Let0123456789876543210FSym1 x0123456789876543210 :: (~>) Nat Nat
-      where
-        Let0123456789876543210FSym1KindInference :: SameKind (Apply (Let0123456789876543210FSym1 x0123456789876543210) arg) (Let0123456789876543210FSym2 x0123456789876543210 arg) =>
-                                                    Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210
-    type instance Apply (Let0123456789876543210FSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210FSym1 x0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210FSym1KindInference) ())
-    type family Let0123456789876543210FSym2 x0123456789876543210 (a0123456789876543210 :: Nat) :: Nat where
-      Let0123456789876543210FSym2 x0123456789876543210 a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
-    type family Let0123456789876543210F x (a :: Nat) :: Nat where
-      Let0123456789876543210F x y = Apply SuccSym0 (Let0123456789876543210ZSym2 y x)
-    data Let0123456789876543210FSym0 x0123456789876543210
+    data Let0123456789876543210FSym0 (x0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
-        Let0123456789876543210FSym0KindInference :: SameKind (Apply Let0123456789876543210FSym0 arg) (Let0123456789876543210FSym1 arg) =>
-                                                    Let0123456789876543210FSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210FSym0 x0123456789876543210 = Let0123456789876543210FSym1 x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210FSym0 where
+        Let0123456789876543210FSym0KindInference :: SameKind (Apply (Let0123456789876543210FSym0 x0123456789876543210) arg) (Let0123456789876543210FSym1 x0123456789876543210 arg) =>
+                                                    Let0123456789876543210FSym0 x0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat (Let0123456789876543210FSym0 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Let0123456789876543210FSym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210FSym0KindInference) ())
-    data Let0123456789876543210FSym1 x0123456789876543210 :: (~>) Nat Nat
+        = snd ((,) Let0123456789876543210FSym0KindInference ())
+    type family Let0123456789876543210FSym1 (x0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
+    type family Let0123456789876543210F (x0123456789876543210 :: Nat) (a :: Nat) :: Nat where
+      Let0123456789876543210F x y = Apply SuccSym0 (Let0123456789876543210ZSym0 y x)
+    data Let0123456789876543210FSym0 (x0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
-        Let0123456789876543210FSym1KindInference :: SameKind (Apply (Let0123456789876543210FSym1 x0123456789876543210) arg) (Let0123456789876543210FSym2 x0123456789876543210 arg) =>
-                                                    Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210
-    type instance Apply (Let0123456789876543210FSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210FSym1 x0123456789876543210) where
+        Let0123456789876543210FSym0KindInference :: SameKind (Apply (Let0123456789876543210FSym0 x0123456789876543210) arg) (Let0123456789876543210FSym1 x0123456789876543210 arg) =>
+                                                    Let0123456789876543210FSym0 x0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat (Let0123456789876543210FSym0 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Let0123456789876543210FSym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210FSym1KindInference) ())
-    type family Let0123456789876543210FSym2 x0123456789876543210 (a0123456789876543210 :: Nat) :: Nat where
-      Let0123456789876543210FSym2 x0123456789876543210 a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
-    type family Let0123456789876543210F x (a :: Nat) :: Nat where
+        = snd ((,) Let0123456789876543210FSym0KindInference ())
+    type family Let0123456789876543210FSym1 (x0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210
+    type family Let0123456789876543210F (x0123456789876543210 :: Nat) (a :: Nat) :: Nat where
       Let0123456789876543210F x y = Apply SuccSym0 y
-    data Let0123456789876543210YSym0 x0123456789876543210
-      where
-        Let0123456789876543210YSym0KindInference :: SameKind (Apply Let0123456789876543210YSym0 arg) (Let0123456789876543210YSym1 arg) =>
-                                                    Let0123456789876543210YSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210YSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210YSym0KindInference) ())
-    type family Let0123456789876543210YSym1 x0123456789876543210 :: Nat where
-      Let0123456789876543210YSym1 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210
-    type family Let0123456789876543210Y x :: Nat where
+    type family Let0123456789876543210YSym0 (x0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210
+    type family Let0123456789876543210Y (x0123456789876543210 :: Nat) :: Nat where
       Let0123456789876543210Y x = Apply SuccSym0 x
     type family Let0123456789876543210ZSym0 where
       Let0123456789876543210ZSym0 = Let0123456789876543210Z
@@ -548,26 +398,19 @@
       Let0123456789876543210Z = Apply SuccSym0 Let0123456789876543210YSym0
     type family Let0123456789876543210Y where
       Let0123456789876543210Y = Apply SuccSym0 ZeroSym0
-    data Let0123456789876543210YSym0 x0123456789876543210
-      where
-        Let0123456789876543210YSym0KindInference :: SameKind (Apply Let0123456789876543210YSym0 arg) (Let0123456789876543210YSym1 arg) =>
-                                                    Let0123456789876543210YSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210YSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210YSym0KindInference) ())
-    type family Let0123456789876543210YSym1 x0123456789876543210 :: Nat where
-      Let0123456789876543210YSym1 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210
-    type family Let0123456789876543210Y x :: Nat where
+    type family Let0123456789876543210YSym0 (x0123456789876543210 :: Nat) :: Nat where
+      Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210
+    type family Let0123456789876543210Y (x0123456789876543210 :: Nat) :: Nat where
       Let0123456789876543210Y x = Apply SuccSym0 ZeroSym0
     type Foo14Sym0 :: (~>) Nat (Nat, Nat)
     data Foo14Sym0 :: (~>) Nat (Nat, Nat)
       where
         Foo14Sym0KindInference :: SameKind (Apply Foo14Sym0 arg) (Foo14Sym1 arg) =>
                                   Foo14Sym0 a0123456789876543210
-    type instance Apply Foo14Sym0 a0123456789876543210 = Foo14 a0123456789876543210
+    type instance Apply @Nat @(Nat,
+                               Nat) Foo14Sym0 a0123456789876543210 = Foo14 a0123456789876543210
     instance SuppressUnusedWarnings Foo14Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo14Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo14Sym0KindInference ())
     type Foo14Sym1 :: Nat -> (Nat, Nat)
     type family Foo14Sym1 (a0123456789876543210 :: Nat) :: (Nat,
                                                             Nat) where
@@ -577,31 +420,31 @@
       where
         Foo13_Sym0KindInference :: SameKind (Apply Foo13_Sym0 arg) (Foo13_Sym1 arg) =>
                                    Foo13_Sym0 a0123456789876543210
-    type instance Apply Foo13_Sym0 a0123456789876543210 = Foo13_ a0123456789876543210
+    type instance Apply @a @a Foo13_Sym0 a0123456789876543210 = Foo13_ a0123456789876543210
     instance SuppressUnusedWarnings Foo13_Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo13_Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo13_Sym0KindInference ())
     type Foo13_Sym1 :: a -> a
-    type family Foo13_Sym1 (a0123456789876543210 :: a) :: a where
+    type family Foo13_Sym1 @a (a0123456789876543210 :: a) :: a where
       Foo13_Sym1 a0123456789876543210 = Foo13_ a0123456789876543210
     type Foo13Sym0 :: forall a. (~>) a a
     data Foo13Sym0 :: (~>) a a
       where
         Foo13Sym0KindInference :: SameKind (Apply Foo13Sym0 arg) (Foo13Sym1 arg) =>
                                   Foo13Sym0 a0123456789876543210
-    type instance Apply Foo13Sym0 a0123456789876543210 = Foo13 a0123456789876543210
+    type instance Apply @a @a Foo13Sym0 a0123456789876543210 = Foo13 a0123456789876543210
     instance SuppressUnusedWarnings Foo13Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo13Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo13Sym0KindInference ())
     type Foo13Sym1 :: forall a. a -> a
-    type family Foo13Sym1 (a0123456789876543210 :: a) :: a where
+    type family Foo13Sym1 @a (a0123456789876543210 :: a) :: a where
       Foo13Sym1 a0123456789876543210 = Foo13 a0123456789876543210
     type Foo12Sym0 :: (~>) Nat Nat
     data Foo12Sym0 :: (~>) Nat Nat
       where
         Foo12Sym0KindInference :: SameKind (Apply Foo12Sym0 arg) (Foo12Sym1 arg) =>
                                   Foo12Sym0 a0123456789876543210
-    type instance Apply Foo12Sym0 a0123456789876543210 = Foo12 a0123456789876543210
+    type instance Apply @Nat @Nat Foo12Sym0 a0123456789876543210 = Foo12 a0123456789876543210
     instance SuppressUnusedWarnings Foo12Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo12Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo12Sym0KindInference ())
     type Foo12Sym1 :: Nat -> Nat
     type family Foo12Sym1 (a0123456789876543210 :: Nat) :: Nat where
       Foo12Sym1 a0123456789876543210 = Foo12 a0123456789876543210
@@ -610,9 +453,9 @@
       where
         Foo11Sym0KindInference :: SameKind (Apply Foo11Sym0 arg) (Foo11Sym1 arg) =>
                                   Foo11Sym0 a0123456789876543210
-    type instance Apply Foo11Sym0 a0123456789876543210 = Foo11 a0123456789876543210
+    type instance Apply @Nat @Nat Foo11Sym0 a0123456789876543210 = Foo11 a0123456789876543210
     instance SuppressUnusedWarnings Foo11Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo11Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo11Sym0KindInference ())
     type Foo11Sym1 :: Nat -> Nat
     type family Foo11Sym1 (a0123456789876543210 :: Nat) :: Nat where
       Foo11Sym1 a0123456789876543210 = Foo11 a0123456789876543210
@@ -621,9 +464,9 @@
       where
         Foo10Sym0KindInference :: SameKind (Apply Foo10Sym0 arg) (Foo10Sym1 arg) =>
                                   Foo10Sym0 a0123456789876543210
-    type instance Apply Foo10Sym0 a0123456789876543210 = Foo10 a0123456789876543210
+    type instance Apply @Nat @Nat Foo10Sym0 a0123456789876543210 = Foo10 a0123456789876543210
     instance SuppressUnusedWarnings Foo10Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo10Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo10Sym0KindInference ())
     type Foo10Sym1 :: Nat -> Nat
     type family Foo10Sym1 (a0123456789876543210 :: Nat) :: Nat where
       Foo10Sym1 a0123456789876543210 = Foo10 a0123456789876543210
@@ -632,9 +475,9 @@
       where
         Foo9Sym0KindInference :: SameKind (Apply Foo9Sym0 arg) (Foo9Sym1 arg) =>
                                  Foo9Sym0 a0123456789876543210
-    type instance Apply Foo9Sym0 a0123456789876543210 = Foo9 a0123456789876543210
+    type instance Apply @Nat @Nat Foo9Sym0 a0123456789876543210 = Foo9 a0123456789876543210
     instance SuppressUnusedWarnings Foo9Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo9Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo9Sym0KindInference ())
     type Foo9Sym1 :: Nat -> Nat
     type family Foo9Sym1 (a0123456789876543210 :: Nat) :: Nat where
       Foo9Sym1 a0123456789876543210 = Foo9 a0123456789876543210
@@ -643,9 +486,9 @@
       where
         Foo8Sym0KindInference :: SameKind (Apply Foo8Sym0 arg) (Foo8Sym1 arg) =>
                                  Foo8Sym0 a0123456789876543210
-    type instance Apply Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210
+    type instance Apply @Nat @Nat Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210
     instance SuppressUnusedWarnings Foo8Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo8Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo8Sym0KindInference ())
     type Foo8Sym1 :: Nat -> Nat
     type family Foo8Sym1 (a0123456789876543210 :: Nat) :: Nat where
       Foo8Sym1 a0123456789876543210 = Foo8 a0123456789876543210
@@ -654,9 +497,9 @@
       where
         Foo7Sym0KindInference :: SameKind (Apply Foo7Sym0 arg) (Foo7Sym1 arg) =>
                                  Foo7Sym0 a0123456789876543210
-    type instance Apply Foo7Sym0 a0123456789876543210 = Foo7 a0123456789876543210
+    type instance Apply @Nat @Nat Foo7Sym0 a0123456789876543210 = Foo7 a0123456789876543210
     instance SuppressUnusedWarnings Foo7Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo7Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo7Sym0KindInference ())
     type Foo7Sym1 :: Nat -> Nat
     type family Foo7Sym1 (a0123456789876543210 :: Nat) :: Nat where
       Foo7Sym1 a0123456789876543210 = Foo7 a0123456789876543210
@@ -665,9 +508,9 @@
       where
         Foo6Sym0KindInference :: SameKind (Apply Foo6Sym0 arg) (Foo6Sym1 arg) =>
                                  Foo6Sym0 a0123456789876543210
-    type instance Apply Foo6Sym0 a0123456789876543210 = Foo6 a0123456789876543210
+    type instance Apply @Nat @Nat Foo6Sym0 a0123456789876543210 = Foo6 a0123456789876543210
     instance SuppressUnusedWarnings Foo6Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo6Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo6Sym0KindInference ())
     type Foo6Sym1 :: Nat -> Nat
     type family Foo6Sym1 (a0123456789876543210 :: Nat) :: Nat where
       Foo6Sym1 a0123456789876543210 = Foo6 a0123456789876543210
@@ -676,9 +519,9 @@
       where
         Foo5Sym0KindInference :: SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>
                                  Foo5Sym0 a0123456789876543210
-    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210
+    type instance Apply @Nat @Nat Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210
     instance SuppressUnusedWarnings Foo5Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo5Sym0KindInference ())
     type Foo5Sym1 :: Nat -> Nat
     type family Foo5Sym1 (a0123456789876543210 :: Nat) :: Nat where
       Foo5Sym1 a0123456789876543210 = Foo5 a0123456789876543210
@@ -687,9 +530,9 @@
       where
         Foo4Sym0KindInference :: SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>
                                  Foo4Sym0 a0123456789876543210
-    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210
+    type instance Apply @Nat @Nat Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210
     instance SuppressUnusedWarnings Foo4Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo4Sym0KindInference ())
     type Foo4Sym1 :: Nat -> Nat
     type family Foo4Sym1 (a0123456789876543210 :: Nat) :: Nat where
       Foo4Sym1 a0123456789876543210 = Foo4 a0123456789876543210
@@ -698,9 +541,9 @@
       where
         Foo3Sym0KindInference :: SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>
                                  Foo3Sym0 a0123456789876543210
-    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210
+    type instance Apply @Nat @Nat Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210
     instance SuppressUnusedWarnings Foo3Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo3Sym0KindInference ())
     type Foo3Sym1 :: Nat -> Nat
     type family Foo3Sym1 (a0123456789876543210 :: Nat) :: Nat where
       Foo3Sym1 a0123456789876543210 = Foo3 a0123456789876543210
@@ -712,270 +555,276 @@
       where
         Foo1Sym0KindInference :: SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>
                                  Foo1Sym0 a0123456789876543210
-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210
+    type instance Apply @Nat @Nat Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210
     instance SuppressUnusedWarnings Foo1Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo1Sym0KindInference ())
     type Foo1Sym1 :: Nat -> Nat
     type family Foo1Sym1 (a0123456789876543210 :: Nat) :: Nat where
       Foo1Sym1 a0123456789876543210 = Foo1 a0123456789876543210
     type Foo14 :: Nat -> (Nat, Nat)
     type family Foo14 (a :: Nat) :: (Nat, Nat) where
-      Foo14 x = Apply (Apply Tuple2Sym0 (Let0123456789876543210ZSym1 x)) (Let0123456789876543210YSym1 x)
+      Foo14 x = Apply (Apply Tuple2Sym0 (Let0123456789876543210ZSym0 x)) (Let0123456789876543210YSym0 x)
     type Foo13_ :: a -> a
-    type family Foo13_ (a :: a) :: a where
+    type family Foo13_ @a (a :: a) :: a where
       Foo13_ y = y
     type Foo13 :: forall a. a -> a
-    type family Foo13 (a :: a) :: a where
-      Foo13 x = Apply Foo13_Sym0 (Let0123456789876543210BarSym1 x)
+    type family Foo13 @a (a :: a) :: a where
+      Foo13 @a (x :: a) = Apply Foo13_Sym0 (Let0123456789876543210BarSym0 a x)
     type Foo12 :: Nat -> Nat
     type family Foo12 (a :: Nat) :: Nat where
-      Foo12 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) x) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))
+      Foo12 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) x) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))
     type Foo11 :: Nat -> Nat
     type family Foo11 (a :: Nat) :: Nat where
-      Foo11 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) (Apply SuccSym0 ZeroSym0)) (Let0123456789876543210ZSym1 x)
+      Foo11 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (Apply SuccSym0 ZeroSym0)) (Let0123456789876543210ZSym0 x)
     type Foo10 :: Nat -> Nat
     type family Foo10 (a :: Nat) :: Nat where
-      Foo10 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) (Apply SuccSym0 ZeroSym0)) x
+      Foo10 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (Apply SuccSym0 ZeroSym0)) x
     type Foo9 :: Nat -> Nat
     type family Foo9 (a :: Nat) :: Nat where
-      Foo9 x = Apply (Let0123456789876543210ZSym1 x) x
+      Foo9 x = Apply (Let0123456789876543210ZSym0 x) x
     type Foo8 :: Nat -> Nat
     type family Foo8 (a :: Nat) :: Nat where
-      Foo8 x = Let0123456789876543210ZSym1 x
+      Foo8 x = Let0123456789876543210ZSym0 x
     type Foo7 :: Nat -> Nat
     type family Foo7 (a :: Nat) :: Nat where
-      Foo7 x = Let0123456789876543210XSym1 x
+      Foo7 x = Let0123456789876543210XSym0 x
     type Foo6 :: Nat -> Nat
     type family Foo6 (a :: Nat) :: Nat where
-      Foo6 x = Let0123456789876543210ZSym1 x
+      Foo6 x = Let0123456789876543210ZSym0 x
     type Foo5 :: Nat -> Nat
     type family Foo5 (a :: Nat) :: Nat where
-      Foo5 x = Apply (Let0123456789876543210FSym1 x) x
+      Foo5 x = Apply (Let0123456789876543210FSym0 x) x
     type Foo4 :: Nat -> Nat
     type family Foo4 (a :: Nat) :: Nat where
-      Foo4 x = Apply (Let0123456789876543210FSym1 x) x
+      Foo4 x = Apply (Let0123456789876543210FSym0 x) x
     type Foo3 :: Nat -> Nat
     type family Foo3 (a :: Nat) :: Nat where
-      Foo3 x = Let0123456789876543210YSym1 x
+      Foo3 x = Let0123456789876543210YSym0 x
     type Foo2 :: Nat
     type family Foo2 :: Nat where
       Foo2 = Let0123456789876543210ZSym0
     type Foo1 :: Nat -> Nat
     type family Foo1 (a :: Nat) :: Nat where
-      Foo1 x = Let0123456789876543210YSym1 x
+      Foo1 x = Let0123456789876543210YSym0 x
     sFoo14 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo14Sym0 t :: (Nat, Nat))
+      (forall (t :: Nat). Sing t -> Sing (Foo14 t :: (Nat, Nat)) :: Type)
     sFoo13_ ::
-      forall a (t :: a). Sing t -> Sing (Apply Foo13_Sym0 t :: a)
-    sFoo13 ::
-      forall a (t :: a). Sing t -> Sing (Apply Foo13Sym0 t :: a)
+      (forall (t :: a). Sing t -> Sing (Foo13_ t :: a) :: Type)
+    sFoo13 :: forall a (t :: a). Sing t -> Sing (Foo13 t :: a)
     sFoo12 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo12Sym0 t :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Foo12 t :: Nat) :: Type)
     sFoo11 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo11Sym0 t :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Foo11 t :: Nat) :: Type)
     sFoo10 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo10Sym0 t :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Foo10 t :: Nat) :: Type)
     sFoo9 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo9Sym0 t :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Foo9 t :: Nat) :: Type)
     sFoo8 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo8Sym0 t :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Foo8 t :: Nat) :: Type)
     sFoo7 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo7Sym0 t :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Foo7 t :: Nat) :: Type)
     sFoo6 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo6Sym0 t :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Foo6 t :: Nat) :: Type)
     sFoo5 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo5Sym0 t :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Foo5 t :: Nat) :: Type)
     sFoo4 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo4Sym0 t :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Foo4 t :: Nat) :: Type)
     sFoo3 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo3Sym0 t :: Nat)
-    sFoo2 :: Sing (Foo2Sym0 :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Foo3 t :: Nat) :: Type)
+    sFoo2 :: (Sing (Foo2 :: Nat) :: Type)
     sFoo1 ::
-      forall (t :: Nat). Sing t -> Sing (Apply Foo1Sym0 t :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Foo1 t :: Nat) :: Type)
     sFoo14 (sX :: Sing x)
       = let
-          sZ :: Sing @_ (Let0123456789876543210ZSym1 x)
-          sY :: Sing @_ (Let0123456789876543210YSym1 x)
+          sZ :: Sing @_ (Let0123456789876543210Z x)
+          sY :: Sing @_ (Let0123456789876543210Y x)
           sX_0123456789876543210 ::
-            Sing @_ (Let0123456789876543210X_0123456789876543210Sym1 x)
+            Sing @_ (Let0123456789876543210X_0123456789876543210 x)
           sZ
-            = (id
-                 @(Sing (Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x))))
-                (case sX_0123456789876543210 of
-                   STuple2 _ (sY_0123456789876543210 :: Sing y_0123456789876543210)
-                     -> sY_0123456789876543210)
+            = applySing
+                (singFun1
+                   @(LamCases_0123456789876543210Sym0 x)
+                   (\cases
+                      (STuple2 _ (sY_0123456789876543210 :: Sing y_0123456789876543210))
+                        -> sY_0123456789876543210))
+                sX_0123456789876543210
           sY
-            = (id
-                 @(Sing (Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x))))
-                (case sX_0123456789876543210 of
-                   STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _
-                     -> sY_0123456789876543210)
+            = applySing
+                (singFun1
+                   @(LamCases_0123456789876543210Sym0 x)
+                   (\cases
+                      (STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _)
+                        -> sY_0123456789876543210))
+                sX_0123456789876543210
           sX_0123456789876543210
-            = (applySing
-                 ((applySing ((singFun2 @Tuple2Sym0) STuple2))
-                    ((applySing ((singFun1 @SuccSym0) SSucc)) sX)))
+            = applySing
+                (applySing
+                   (singFun2 @Tuple2Sym0 STuple2)
+                   (applySing (singFun1 @SuccSym0 SSucc) sX))
                 sX
-        in (applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sZ)) sY
+        in applySing (applySing (singFun2 @Tuple2Sym0 STuple2) sZ) sY
     sFoo13_ (sY :: Sing y) = sY
     sFoo13 (sX :: Sing x)
       = let
-          sBar :: Sing (Let0123456789876543210BarSym1 x :: a)
+          sBar :: (Sing (Let0123456789876543210Bar a x :: a) :: Type)
           sBar = sX
-        in (applySing ((singFun1 @Foo13_Sym0) sFoo13_)) sBar
+        in applySing (singFun1 @Foo13_Sym0 sFoo13_) sBar
     sFoo12 (sX :: Sing x)
       = let
           (%+) ::
-            forall (t :: Nat) (t :: Nat). Sing t
-                                          -> Sing t
-                                             -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat)
+            (forall (t :: Nat) (t :: Nat).
+             Sing t
+             -> Sing t -> Sing ((<<<%%%%%%%%%%%%%%%%%%%%) x t t :: Nat) :: Type)
           (%+) SZero (sM :: Sing m) = sM
           (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)
-            = (applySing ((singFun1 @SuccSym0) SSucc))
-                ((applySing
-                    ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))
-                       sN))
+            = applySing
+                (singFun1 @SuccSym0 SSucc)
+                (applySing
+                   (applySing (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (%+)) sN)
                    sX)
         in
-          (applySing
-             ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))
-                sX))
-            ((applySing ((singFun1 @SuccSym0) SSucc))
-               ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))
+          applySing
+            (applySing (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (%+)) sX)
+            (applySing
+               (singFun1 @SuccSym0 SSucc)
+               (applySing (singFun1 @SuccSym0 SSucc) SZero))
     sFoo11 (sX :: Sing x)
       = let
-          sZ :: Sing (Let0123456789876543210ZSym1 x :: Nat)
+          sZ :: (Sing (Let0123456789876543210Z x :: Nat) :: Type)
           (%+) ::
-            forall (t :: Nat) (t :: Nat). Sing t
-                                          -> Sing t
-                                             -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat)
+            (forall (t :: Nat) (t :: Nat).
+             Sing t
+             -> Sing t -> Sing ((<<<%%%%%%%%%%%%%%%%%%%%) x t t :: Nat) :: Type)
           sZ = sX
           (%+) SZero (sM :: Sing m) = sM
           (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)
-            = (applySing ((singFun1 @SuccSym0) SSucc))
-                ((applySing
-                    ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))
-                       sN))
+            = applySing
+                (singFun1 @SuccSym0 SSucc)
+                (applySing
+                   (applySing (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (%+)) sN)
                    sM)
         in
-          (applySing
-             ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))
-                ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
+          applySing
+            (applySing
+               (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (%+))
+               (applySing (singFun1 @SuccSym0 SSucc) SZero))
             sZ
     sFoo10 (sX :: Sing x)
       = let
           (%+) ::
-            forall (t :: Nat) (t :: Nat). Sing t
-                                          -> Sing t
-                                             -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat)
+            (forall (t :: Nat) (t :: Nat).
+             Sing t
+             -> Sing t -> Sing ((<<<%%%%%%%%%%%%%%%%%%%%) x t t :: Nat) :: Type)
           (%+) SZero (sM :: Sing m) = sM
           (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)
-            = (applySing ((singFun1 @SuccSym0) SSucc))
-                ((applySing
-                    ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))
-                       sN))
+            = applySing
+                (singFun1 @SuccSym0 SSucc)
+                (applySing
+                   (applySing (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (%+)) sN)
                    sM)
         in
-          (applySing
-             ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))
-                ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
+          applySing
+            (applySing
+               (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (%+))
+               (applySing (singFun1 @SuccSym0 SSucc) SZero))
             sX
     sFoo9 (sX :: Sing x)
       = let
           sZ ::
-            forall (t :: Nat). Sing t
-                               -> Sing (Apply (Let0123456789876543210ZSym1 x) t :: Nat)
+            (forall (t :: Nat).
+             Sing t -> Sing (Let0123456789876543210Z x t :: Nat) :: Type)
           sZ (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            = (applySing
-                 ((singFun1
-                     @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) x))
-                    (\ sX -> case sX of (_ :: Sing x) -> sX)))
+            = applySing
+                (singFun1
+                   @(LamCases_0123456789876543210Sym0 a_0123456789876543210 x)
+                   (\cases (sX :: Sing x) -> sX))
                 sA_0123456789876543210
-        in (applySing ((singFun1 @(Let0123456789876543210ZSym1 x)) sZ)) sX
+        in applySing (singFun1 @(Let0123456789876543210ZSym0 x) sZ) sX
     sFoo8 (sX :: Sing x)
       = let
-          sZ :: Sing (Let0123456789876543210ZSym1 x :: Nat)
+          sZ :: (Sing (Let0123456789876543210Z x :: Nat) :: Type)
           sZ
-            = (applySing
-                 ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x))
-                    (\ sX -> case sX of (_ :: Sing x) -> sX)))
+            = applySing
+                (singFun1
+                   @(LamCases_0123456789876543210Sym0 x)
+                   (\cases (sX :: Sing x) -> sX))
                 SZero
         in sZ
     sFoo7 (sX :: Sing x)
       = let
-          sX :: Sing (Let0123456789876543210XSym1 x :: Nat)
+          sX :: (Sing (Let0123456789876543210X x :: Nat) :: Type)
           sX = SZero
         in sX
     sFoo6 (sX :: Sing x)
       = let
           sF ::
-            forall (t :: Nat). Sing t
-                               -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat)
-          sF (sY :: Sing y) = (applySing ((singFun1 @SuccSym0) SSucc)) sY in
+            (forall (t :: Nat).
+             Sing t -> Sing (Let0123456789876543210F x t :: Nat) :: Type)
+          sF (sY :: Sing y) = applySing (singFun1 @SuccSym0 SSucc) sY in
         let
-          sZ :: Sing (Let0123456789876543210ZSym1 x :: Nat)
-          sZ
-            = (applySing ((singFun1 @(Let0123456789876543210FSym1 x)) sF)) sX
+          sZ :: (Sing (Let0123456789876543210Z x :: Nat) :: Type)
+          sZ = applySing (singFun1 @(Let0123456789876543210FSym0 x) sF) sX
         in sZ
     sFoo5 (sX :: Sing x)
       = let
           sF ::
-            forall (t :: Nat). Sing t
-                               -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat)
+            (forall (t :: Nat).
+             Sing t -> Sing (Let0123456789876543210F x t :: Nat) :: Type)
           sF (sY :: Sing y)
             = let
-                sZ :: Sing (Let0123456789876543210ZSym2 y x :: Nat)
-                sZ = (applySing ((singFun1 @SuccSym0) SSucc)) sY
-              in (applySing ((singFun1 @SuccSym0) SSucc)) sZ
-        in (applySing ((singFun1 @(Let0123456789876543210FSym1 x)) sF)) sX
+                sZ :: (Sing (Let0123456789876543210Z y x :: Nat) :: Type)
+                sZ = applySing (singFun1 @SuccSym0 SSucc) sY
+              in applySing (singFun1 @SuccSym0 SSucc) sZ
+        in applySing (singFun1 @(Let0123456789876543210FSym0 x) sF) sX
     sFoo4 (sX :: Sing x)
       = let
           sF ::
-            forall (t :: Nat). Sing t
-                               -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat)
-          sF (sY :: Sing y) = (applySing ((singFun1 @SuccSym0) SSucc)) sY
-        in (applySing ((singFun1 @(Let0123456789876543210FSym1 x)) sF)) sX
+            (forall (t :: Nat).
+             Sing t -> Sing (Let0123456789876543210F x t :: Nat) :: Type)
+          sF (sY :: Sing y) = applySing (singFun1 @SuccSym0 SSucc) sY
+        in applySing (singFun1 @(Let0123456789876543210FSym0 x) sF) sX
     sFoo3 (sX :: Sing x)
       = let
-          sY :: Sing (Let0123456789876543210YSym1 x :: Nat)
-          sY = (applySing ((singFun1 @SuccSym0) SSucc)) sX
+          sY :: (Sing (Let0123456789876543210Y x :: Nat) :: Type)
+          sY = applySing (singFun1 @SuccSym0 SSucc) sX
         in sY
     sFoo2
       = let
-          sZ :: Sing @_ Let0123456789876543210ZSym0
-          sY :: Sing @_ Let0123456789876543210YSym0
-          sZ = (applySing ((singFun1 @SuccSym0) SSucc)) sY
-          sY = (applySing ((singFun1 @SuccSym0) SSucc)) SZero
+          sZ :: Sing @_ Let0123456789876543210Z
+          sY :: Sing @_ Let0123456789876543210Y
+          sZ = applySing (singFun1 @SuccSym0 SSucc) sY
+          sY = applySing (singFun1 @SuccSym0 SSucc) SZero
         in sZ
     sFoo1 (sX :: Sing x)
       = let
-          sY :: Sing (Let0123456789876543210YSym1 x :: Nat)
-          sY = (applySing ((singFun1 @SuccSym0) SSucc)) SZero
+          sY :: (Sing (Let0123456789876543210Y x :: Nat) :: Type)
+          sY = applySing (singFun1 @SuccSym0 SSucc) SZero
         in sY
     instance SingI (Foo14Sym0 :: (~>) Nat (Nat, Nat)) where
-      sing = (singFun1 @Foo14Sym0) sFoo14
+      sing = singFun1 @Foo14Sym0 sFoo14
     instance SingI (Foo13_Sym0 :: (~>) a a) where
-      sing = (singFun1 @Foo13_Sym0) sFoo13_
+      sing = singFun1 @Foo13_Sym0 sFoo13_
     instance SingI (Foo13Sym0 :: (~>) a a) where
-      sing = (singFun1 @Foo13Sym0) sFoo13
+      sing = singFun1 @Foo13Sym0 sFoo13
     instance SingI (Foo12Sym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @Foo12Sym0) sFoo12
+      sing = singFun1 @Foo12Sym0 sFoo12
     instance SingI (Foo11Sym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @Foo11Sym0) sFoo11
+      sing = singFun1 @Foo11Sym0 sFoo11
     instance SingI (Foo10Sym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @Foo10Sym0) sFoo10
+      sing = singFun1 @Foo10Sym0 sFoo10
     instance SingI (Foo9Sym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @Foo9Sym0) sFoo9
+      sing = singFun1 @Foo9Sym0 sFoo9
     instance SingI (Foo8Sym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @Foo8Sym0) sFoo8
+      sing = singFun1 @Foo8Sym0 sFoo8
     instance SingI (Foo7Sym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @Foo7Sym0) sFoo7
+      sing = singFun1 @Foo7Sym0 sFoo7
     instance SingI (Foo6Sym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @Foo6Sym0) sFoo6
+      sing = singFun1 @Foo6Sym0 sFoo6
     instance SingI (Foo5Sym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @Foo5Sym0) sFoo5
+      sing = singFun1 @Foo5Sym0 sFoo5
     instance SingI (Foo4Sym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @Foo4Sym0) sFoo4
+      sing = singFun1 @Foo4Sym0 sFoo4
     instance SingI (Foo3Sym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @Foo3Sym0) sFoo3
+      sing = singFun1 @Foo3Sym0 sFoo3
     instance SingI (Foo1Sym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @Foo1Sym0) sFoo1
+      sing = singFun1 @Foo1Sym0 sFoo1
diff --git a/tests/compile-and-dump/Singletons/Maybe.golden b/tests/compile-and-dump/Singletons/Maybe.golden
--- a/tests/compile-and-dump/Singletons/Maybe.golden
+++ b/tests/compile-and-dump/Singletons/Maybe.golden
@@ -8,89 +8,37 @@
       = Nothing | Just a
       deriving (Eq, Show)
     type NothingSym0 :: forall a. Maybe a
-    type family NothingSym0 :: Maybe a where
+    type family NothingSym0 @a :: Maybe a where
       NothingSym0 = Nothing
     type JustSym0 :: forall a. (~>) a (Maybe a)
     data JustSym0 :: (~>) a (Maybe a)
       where
         JustSym0KindInference :: SameKind (Apply JustSym0 arg) (JustSym1 arg) =>
                                  JustSym0 a0123456789876543210
-    type instance Apply JustSym0 a0123456789876543210 = Just a0123456789876543210
+    type instance Apply @a @(Maybe a) JustSym0 a0123456789876543210 = Just a0123456789876543210
     instance SuppressUnusedWarnings JustSym0 where
-      suppressUnusedWarnings = snd (((,) JustSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) JustSym0KindInference ())
     type JustSym1 :: forall a. a -> Maybe a
-    type family JustSym1 (a0123456789876543210 :: a) :: Maybe a where
+    type family JustSym1 @a (a0123456789876543210 :: a) :: Maybe a where
       JustSym1 a0123456789876543210 = Just a0123456789876543210
-    type TFHelper_0123456789876543210 :: Maybe a -> Maybe a -> Bool
-    type family TFHelper_0123456789876543210 (a :: Maybe a) (a :: Maybe a) :: Bool where
-      TFHelper_0123456789876543210 Nothing Nothing = TrueSym0
-      TFHelper_0123456789876543210 Nothing (Just _) = FalseSym0
-      TFHelper_0123456789876543210 (Just _) Nothing = FalseSym0
-      TFHelper_0123456789876543210 (Just a_0123456789876543210) (Just b_0123456789876543210) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
-    type TFHelper_0123456789876543210Sym0 :: (~>) (Maybe a) ((~>) (Maybe a) Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) (Maybe a) ((~>) (Maybe a) Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Maybe a
-                                             -> (~>) (Maybe a) Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Maybe a) :: (~>) (Maybe a) Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Maybe a -> Maybe a -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Maybe a) (a0123456789876543210 :: Maybe a) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
+    type TFHelper_0123456789876543210 :: forall a. Maybe a
+                                                   -> Maybe a -> Bool
+    type family TFHelper_0123456789876543210 @a (a :: Maybe a) (a :: Maybe a) :: Bool where
+      TFHelper_0123456789876543210 @a (Nothing :: Maybe a) (Nothing :: Maybe a) = TrueSym0
+      TFHelper_0123456789876543210 @a (Nothing :: Maybe a) (Just _ :: Maybe a) = FalseSym0
+      TFHelper_0123456789876543210 @a (Just _ :: Maybe a) (Nothing :: Maybe a) = FalseSym0
+      TFHelper_0123456789876543210 @a (Just a_0123456789876543210 :: Maybe a) (Just b_0123456789876543210 :: Maybe a) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
     instance PEq (Maybe a) where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> Maybe a -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Maybe a) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where
-      ShowsPrec_0123456789876543210 _ Nothing a_0123456789876543210 = Apply (Apply ShowStringSym0 "Nothing") a_0123456789876543210
-      ShowsPrec_0123456789876543210 p_0123456789876543210 (Just arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Just ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> Maybe a -> (~>) GHC.Types.Symbol GHC.Types.Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Maybe a) :: (~>) GHC.Types.Symbol GHC.Types.Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> Maybe a -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Maybe a) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+      type (==) a a = TFHelper_0123456789876543210 a a
+    type ShowsPrec_0123456789876543210 :: forall a. GHC.Internal.Bignum.Natural.Natural
+                                                    -> Maybe a
+                                                       -> GHC.Internal.Types.Symbol
+                                                          -> GHC.Internal.Types.Symbol
+    type family ShowsPrec_0123456789876543210 @a (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Maybe a) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where
+      ShowsPrec_0123456789876543210 @a (_ :: GHC.Internal.Bignum.Natural.Natural) (Nothing :: Maybe a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply ShowStringSym0 "Nothing") a_0123456789876543210
+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (Just arg_0123456789876543210 :: Maybe a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Just ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210
     instance PShow (Maybe a) where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
     data SMaybe :: forall a. Maybe a -> Type
       where
         SNothing :: forall a. SMaybe (Nothing :: Maybe a)
@@ -102,74 +50,69 @@
       fromSing (SJust b) = Just (fromSing b)
       toSing Nothing = SomeSing SNothing
       toSing (Just (b :: Demote a))
-        = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SJust c)
+        = (\cases (SomeSing c) -> SomeSing (SJust c))
+            (toSing b :: SomeSing a)
     instance SEq a => SEq (Maybe a) where
-      (%==) ::
-        forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1
-                                                -> Sing t2
-                                                   -> Sing (Apply (Apply ((==@#@$) :: TyFun (Maybe a) ((~>) (Maybe a) Bool)
-                                                                                      -> Type) t1) t2)
       (%==) SNothing SNothing = STrue
       (%==) SNothing (SJust _) = SFalse
       (%==) (SJust _) SNothing = SFalse
       (%==)
         (SJust (sA_0123456789876543210 :: Sing a_0123456789876543210))
         (SJust (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
+        = applySing
+            (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
             sB_0123456789876543210
     instance SShow a => SShow (Maybe a) where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: Maybe a)
-               (t3 :: GHC.Types.Symbol). Sing t1
-                                         -> Sing t2
-                                            -> Sing t3
-                                               -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-                                                                                              -> Type) t1) t2) t3)
       sShowsPrec
         _
         SNothing
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "Nothing")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Nothing"))
             sA_0123456789876543210
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         (SJust (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "Just "))))
-                   ((applySing
-                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                          (sFromInteger (sing :: Sing 11))))
-                      sArg_0123456789876543210))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Just ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @ShowsPrecSym0 sShowsPrec)
+                        (sFromInteger (sing :: Sing 11)))
+                     sArg_0123456789876543210)))
             sA_0123456789876543210
     instance SDecide a => SDecide (Maybe a) where
       (%~) SNothing SNothing = Proved Refl
-      (%~) SNothing (SJust _) = Disproved (\ x -> case x of {})
-      (%~) (SJust _) SNothing = Disproved (\ x -> case x of {})
+      (%~) SNothing (SJust _) = Disproved (\case)
+      (%~) (SJust _) SNothing = Disproved (\case)
       (%~) (SJust a) (SJust b)
-        = case ((%~) a) b of
-            Proved Refl -> Proved Refl
-            Disproved contra
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
+        = (\cases
+             (Proved Refl) -> Proved Refl
+             (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b)
+    instance Eq (SMaybe (z :: Maybe a)) where
+      (==) _ _ = True
     instance SDecide a =>
-             Data.Type.Equality.TestEquality (SMaybe :: Maybe a -> Type) where
-      Data.Type.Equality.testEquality
+             GHC.Internal.Data.Type.Equality.TestEquality (SMaybe :: Maybe a
+                                                                     -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
         = Data.Singletons.Decide.decideEquality
     instance SDecide a =>
-             Data.Type.Coercion.TestCoercion (SMaybe :: Maybe a -> Type) where
-      Data.Type.Coercion.testCoercion
+             GHC.Internal.Data.Type.Coercion.TestCoercion (SMaybe :: Maybe a
+                                                                     -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
         = Data.Singletons.Decide.decideCoercion
     deriving instance Data.Singletons.ShowSing.ShowSing a =>
                       Show (SMaybe (z :: Maybe a))
@@ -180,4 +123,4 @@
     instance SingI1 Just where
       liftSing = SJust
     instance SingI (JustSym0 :: (~>) a (Maybe a)) where
-      sing = (singFun1 @JustSym0) SJust
+      sing = singFun1 @JustSym0 SJust
diff --git a/tests/compile-and-dump/Singletons/Nat.golden b/tests/compile-and-dump/Singletons/Nat.golden
--- a/tests/compile-and-dump/Singletons/Nat.golden
+++ b/tests/compile-and-dump/Singletons/Nat.golden
@@ -20,7 +20,7 @@
       deriving (Eq, Show, Read, Ord)
     plus :: Nat -> Nat -> Nat
     plus Zero m = m
-    plus (Succ n) m = Succ ((plus n) m)
+    plus (Succ n) m = Succ (plus n m)
     pred :: Nat -> Nat
     pred Zero = Zero
     pred (Succ n) = n
@@ -32,9 +32,9 @@
       where
         SuccSym0KindInference :: SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>
                                  SuccSym0 a0123456789876543210
-    type instance Apply SuccSym0 a0123456789876543210 = Succ a0123456789876543210
+    type instance Apply @Nat @Nat SuccSym0 a0123456789876543210 = Succ a0123456789876543210
     instance SuppressUnusedWarnings SuccSym0 where
-      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SuccSym0KindInference ())
     type SuccSym1 :: Nat -> Nat
     type family SuccSym1 (a0123456789876543210 :: Nat) :: Nat where
       SuccSym1 a0123456789876543210 = Succ a0123456789876543210
@@ -43,9 +43,9 @@
       where
         PredSym0KindInference :: SameKind (Apply PredSym0 arg) (PredSym1 arg) =>
                                  PredSym0 a0123456789876543210
-    type instance Apply PredSym0 a0123456789876543210 = Pred a0123456789876543210
+    type instance Apply @Nat @Nat PredSym0 a0123456789876543210 = Pred a0123456789876543210
     instance SuppressUnusedWarnings PredSym0 where
-      suppressUnusedWarnings = snd (((,) PredSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) PredSym0KindInference ())
     type PredSym1 :: Nat -> Nat
     type family PredSym1 (a0123456789876543210 :: Nat) :: Nat where
       PredSym1 a0123456789876543210 = Pred a0123456789876543210
@@ -54,17 +54,17 @@
       where
         PlusSym0KindInference :: SameKind (Apply PlusSym0 arg) (PlusSym1 arg) =>
                                  PlusSym0 a0123456789876543210
-    type instance Apply PlusSym0 a0123456789876543210 = PlusSym1 a0123456789876543210
+    type instance Apply @Nat @((~>) Nat Nat) PlusSym0 a0123456789876543210 = PlusSym1 a0123456789876543210
     instance SuppressUnusedWarnings PlusSym0 where
-      suppressUnusedWarnings = snd (((,) PlusSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) PlusSym0KindInference ())
     type PlusSym1 :: Nat -> (~>) Nat Nat
     data PlusSym1 (a0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
         PlusSym1KindInference :: SameKind (Apply (PlusSym1 a0123456789876543210) arg) (PlusSym2 a0123456789876543210 arg) =>
                                  PlusSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (PlusSym1 a0123456789876543210) a0123456789876543210 = Plus a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat (PlusSym1 a0123456789876543210) a0123456789876543210 = Plus a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (PlusSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) PlusSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) PlusSym1KindInference ())
     type PlusSym2 :: Nat -> Nat -> Nat
     type family PlusSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
       PlusSym2 a0123456789876543210 a0123456789876543210 = Plus a0123456789876543210 a0123456789876543210
@@ -82,119 +82,47 @@
       TFHelper_0123456789876543210 Zero (Succ _) = FalseSym0
       TFHelper_0123456789876543210 (Succ _) Zero = FalseSym0
       TFHelper_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
-    type TFHelper_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Nat -> (~>) Nat Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Nat -> Nat -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PEq Nat where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> Nat -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Nat) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where
+      type (==) a a = TFHelper_0123456789876543210 a a
+    type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                          -> Nat
+                                             -> GHC.Internal.Types.Symbol
+                                                -> GHC.Internal.Types.Symbol
+    type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Nat) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where
       ShowsPrec_0123456789876543210 _ Zero a_0123456789876543210 = Apply (Apply ShowStringSym0 "Zero") a_0123456789876543210
       ShowsPrec_0123456789876543210 p_0123456789876543210 (Succ arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Succ ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> Nat -> (~>) GHC.Types.Symbol GHC.Types.Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Nat) :: (~>) GHC.Types.Symbol GHC.Types.Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> Nat -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Nat) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PShow Nat where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
     type Compare_0123456789876543210 :: Nat -> Nat -> Ordering
     type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where
-      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
-      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
+      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
+      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
       Compare_0123456789876543210 Zero (Succ _) = LTSym0
       Compare_0123456789876543210 (Succ _) Zero = GTSym0
-    type Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: Nat -> (~>) Nat Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: Nat -> Nat -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance POrd Nat where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
+      type Compare a a = Compare_0123456789876543210 a a
     sPred ::
-      forall (t :: Nat). Sing t -> Sing (Apply PredSym0 t :: Nat)
+      (forall (t :: Nat). Sing t -> Sing (Pred t :: Nat) :: Type)
     sPlus ::
-      forall (t :: Nat) (t :: Nat). Sing t
-                                    -> Sing t -> Sing (Apply (Apply PlusSym0 t) t :: Nat)
+      (forall (t :: Nat) (t :: Nat).
+       Sing t -> Sing t -> Sing (Plus t t :: Nat) :: Type)
     sPred SZero = SZero
     sPred (SSucc (sN :: Sing n)) = sN
     sPlus SZero (sM :: Sing m) = sM
     sPlus (SSucc (sN :: Sing n)) (sM :: Sing m)
-      = (applySing ((singFun1 @SuccSym0) SSucc))
-          ((applySing ((applySing ((singFun2 @PlusSym0) sPlus)) sN)) sM)
+      = applySing
+          (singFun1 @SuccSym0 SSucc)
+          (applySing (applySing (singFun2 @PlusSym0 sPlus) sN) sM)
     instance SingI (PredSym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @PredSym0) sPred
+      sing = singFun1 @PredSym0 sPred
     instance SingI (PlusSym0 :: (~>) Nat ((~>) Nat Nat)) where
-      sing = (singFun2 @PlusSym0) sPlus
+      sing = singFun2 @PlusSym0 sPlus
     instance SingI d =>
              SingI (PlusSym1 (d :: Nat) :: (~>) Nat Nat) where
-      sing = (singFun1 @(PlusSym1 (d :: Nat))) (sPlus (sing @d))
+      sing = singFun1 @(PlusSym1 (d :: Nat)) (sPlus (sing @d))
     instance SingI1 (PlusSym1 :: Nat -> (~>) Nat Nat) where
       liftSing (s :: Sing (d :: Nat))
-        = (singFun1 @(PlusSym1 (d :: Nat))) (sPlus s)
+        = singFun1 @(PlusSym1 (d :: Nat)) (sPlus s)
     data SNat :: Nat -> Type
       where
         SZero :: SNat (Zero :: Nat)
@@ -206,105 +134,95 @@
       fromSing (SSucc b) = Succ (fromSing b)
       toSing Zero = SomeSing SZero
       toSing (Succ (b :: Demote Nat))
-        = case toSing b :: SomeSing Nat of SomeSing c -> SomeSing (SSucc c)
+        = (\cases (SomeSing c) -> SomeSing (SSucc c))
+            (toSing b :: SomeSing Nat)
     instance SEq Nat => SEq Nat where
-      (%==) ::
-        forall (t1 :: Nat) (t2 :: Nat). Sing t1
-                                        -> Sing t2
-                                           -> Sing (Apply (Apply ((==@#@$) :: TyFun Nat ((~>) Nat Bool)
-                                                                              -> Type) t1) t2)
       (%==) SZero SZero = STrue
       (%==) SZero (SSucc _) = SFalse
       (%==) (SSucc _) SZero = SFalse
       (%==)
         (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))
         (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
+        = applySing
+            (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
             sB_0123456789876543210
     instance SShow Nat => SShow Nat where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: Nat)
-               (t3 :: GHC.Types.Symbol). Sing t1
-                                         -> Sing t2
-                                            -> Sing t3
-                                               -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-                                                                                              -> Type) t1) t2) t3)
       sShowsPrec
         _
         SZero
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "Zero")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Zero"))
             sA_0123456789876543210
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         (SSucc (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "Succ "))))
-                   ((applySing
-                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                          (sFromInteger (sing :: Sing 11))))
-                      sArg_0123456789876543210))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Succ ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @ShowsPrecSym0 sShowsPrec)
+                        (sFromInteger (sing :: Sing 11)))
+                     sArg_0123456789876543210)))
             sA_0123456789876543210
     instance SOrd Nat => SOrd Nat where
-      sCompare ::
-        forall (t1 :: Nat) (t2 :: Nat). Sing t1
-                                        -> Sing t2
-                                           -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering)
-                                                                                 -> Type) t1) t2)
       sCompare SZero SZero
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
             SNil
       sCompare
         (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))
         (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
                SNil)
       sCompare SZero (SSucc _) = SLT
       sCompare (SSucc _) SZero = SGT
     instance SDecide Nat => SDecide Nat where
       (%~) SZero SZero = Proved Refl
-      (%~) SZero (SSucc _) = Disproved (\ x -> case x of {})
-      (%~) (SSucc _) SZero = Disproved (\ x -> case x of {})
+      (%~) SZero (SSucc _) = Disproved (\case)
+      (%~) (SSucc _) SZero = Disproved (\case)
       (%~) (SSucc a) (SSucc b)
-        = case ((%~) a) b of
-            Proved Refl -> Proved Refl
-            Disproved contra
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
+        = (\cases
+             (Proved Refl) -> Proved Refl
+             (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b)
+    instance Eq (SNat (z :: Nat)) where
+      (==) _ _ = True
     instance SDecide Nat =>
-             Data.Type.Equality.TestEquality (SNat :: Nat -> Type) where
-      Data.Type.Equality.testEquality
+             GHC.Internal.Data.Type.Equality.TestEquality (SNat :: Nat
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
         = Data.Singletons.Decide.decideEquality
     instance SDecide Nat =>
-             Data.Type.Coercion.TestCoercion (SNat :: Nat -> Type) where
-      Data.Type.Coercion.testCoercion
+             GHC.Internal.Data.Type.Coercion.TestCoercion (SNat :: Nat
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
         = Data.Singletons.Decide.decideCoercion
+    instance Ord (SNat (z :: Nat)) where
+      compare _ _ = EQ
     deriving instance Data.Singletons.ShowSing.ShowSing Nat =>
                       Show (SNat (z :: Nat))
     instance SingI Zero where
@@ -314,4 +232,4 @@
     instance SingI1 Succ where
       liftSing = SSucc
     instance SingI (SuccSym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @SuccSym0) SSucc
+      sing = singFun1 @SuccSym0 SSucc
diff --git a/tests/compile-and-dump/Singletons/Natural.golden b/tests/compile-and-dump/Singletons/Natural.golden
--- a/tests/compile-and-dump/Singletons/Natural.golden
+++ b/tests/compile-and-dump/Singletons/Natural.golden
@@ -15,9 +15,9 @@
       where
         MkAgeSym0KindInference :: SameKind (Apply MkAgeSym0 arg) (MkAgeSym1 arg) =>
                                   MkAgeSym0 a0123456789876543210
-    type instance Apply MkAgeSym0 a0123456789876543210 = MkAge a0123456789876543210
+    type instance Apply @Natural @Age MkAgeSym0 a0123456789876543210 = MkAge a0123456789876543210
     instance SuppressUnusedWarnings MkAgeSym0 where
-      suppressUnusedWarnings = snd (((,) MkAgeSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkAgeSym0KindInference ())
     type MkAgeSym1 :: Natural -> Age
     type family MkAgeSym1 (a0123456789876543210 :: Natural) :: Age where
       MkAgeSym1 a0123456789876543210 = MkAge a0123456789876543210
@@ -26,17 +26,17 @@
       where
         AddAgeSym0KindInference :: SameKind (Apply AddAgeSym0 arg) (AddAgeSym1 arg) =>
                                    AddAgeSym0 a0123456789876543210
-    type instance Apply AddAgeSym0 a0123456789876543210 = AddAgeSym1 a0123456789876543210
+    type instance Apply @Age @((~>) Age Age) AddAgeSym0 a0123456789876543210 = AddAgeSym1 a0123456789876543210
     instance SuppressUnusedWarnings AddAgeSym0 where
-      suppressUnusedWarnings = snd (((,) AddAgeSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) AddAgeSym0KindInference ())
     type AddAgeSym1 :: Age -> (~>) Age Age
     data AddAgeSym1 (a0123456789876543210 :: Age) :: (~>) Age Age
       where
         AddAgeSym1KindInference :: SameKind (Apply (AddAgeSym1 a0123456789876543210) arg) (AddAgeSym2 a0123456789876543210 arg) =>
                                    AddAgeSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (AddAgeSym1 a0123456789876543210) a0123456789876543210 = AddAge a0123456789876543210 a0123456789876543210
+    type instance Apply @Age @Age (AddAgeSym1 a0123456789876543210) a0123456789876543210 = AddAge a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (AddAgeSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) AddAgeSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) AddAgeSym1KindInference ())
     type AddAgeSym2 :: Age -> Age -> Age
     type family AddAgeSym2 (a0123456789876543210 :: Age) (a0123456789876543210 :: Age) :: Age where
       AddAgeSym2 a0123456789876543210 a0123456789876543210 = AddAge a0123456789876543210 a0123456789876543210
@@ -44,22 +44,24 @@
     type family AddAge (a :: Age) (a :: Age) :: Age where
       AddAge (MkAge (x :: Natural)) (MkAge (y :: Natural)) = Apply MkAgeSym0 (Apply (Apply (+@#@$) x) y :: Natural)
     sAddAge ::
-      forall (t :: Age) (t :: Age). Sing t
-                                    -> Sing t -> Sing (Apply (Apply AddAgeSym0 t) t :: Age)
+      (forall (t :: Age) (t :: Age).
+       Sing t -> Sing t -> Sing (AddAge t t :: Age) :: Type)
     sAddAge (SMkAge (sX :: Sing x)) (SMkAge (sY :: Sing y))
-      = case ((,) (sX :: Sing x)) (sY :: Sing y) of
-          (,) (_ :: Sing (x :: Natural)) (_ :: Sing (y :: Natural))
-            -> (applySing ((singFun1 @MkAgeSym0) SMkAge))
-                 ((applySing ((applySing ((singFun2 @(+@#@$)) (%+))) sX)) sY ::
-                    Sing (Apply (Apply (+@#@$) x) y :: Natural))
+      = (\cases
+           (_ :: Sing (x :: Natural)) (_ :: Sing (y :: Natural))
+             -> applySing
+                  (singFun1 @MkAgeSym0 SMkAge)
+                  (applySing (applySing (singFun2 @(+@#@$) (%+)) sX) sY ::
+                     Sing (Apply (Apply (+@#@$) x) y :: Natural)))
+          (sX :: Sing x) (sY :: Sing y)
     instance SingI (AddAgeSym0 :: (~>) Age ((~>) Age Age)) where
-      sing = (singFun2 @AddAgeSym0) sAddAge
+      sing = singFun2 @AddAgeSym0 sAddAge
     instance SingI d =>
              SingI (AddAgeSym1 (d :: Age) :: (~>) Age Age) where
-      sing = (singFun1 @(AddAgeSym1 (d :: Age))) (sAddAge (sing @d))
+      sing = singFun1 @(AddAgeSym1 (d :: Age)) (sAddAge (sing @d))
     instance SingI1 (AddAgeSym1 :: Age -> (~>) Age Age) where
       liftSing (s :: Sing (d :: Age))
-        = (singFun1 @(AddAgeSym1 (d :: Age))) (sAddAge s)
+        = singFun1 @(AddAgeSym1 (d :: Age)) (sAddAge s)
     data SAge :: Age -> Type
       where
         SMkAge :: forall (n :: Natural). (Sing n) -> SAge (MkAge n :: Age)
@@ -68,11 +70,11 @@
       type Demote Age = Age
       fromSing (SMkAge b) = MkAge (fromSing b)
       toSing (MkAge (b :: Demote Natural))
-        = case toSing b :: SomeSing Natural of
-            SomeSing c -> SomeSing (SMkAge c)
+        = (\cases (SomeSing c) -> SomeSing (SMkAge c))
+            (toSing b :: SomeSing Natural)
     instance SingI n => SingI (MkAge (n :: Natural)) where
       sing = SMkAge sing
     instance SingI1 MkAge where
       liftSing = SMkAge
     instance SingI (MkAgeSym0 :: (~>) Natural Age) where
-      sing = (singFun1 @MkAgeSym0) SMkAge
+      sing = singFun1 @MkAgeSym0 SMkAge
diff --git a/tests/compile-and-dump/Singletons/NegativeLiterals.golden b/tests/compile-and-dump/Singletons/NegativeLiterals.golden
--- a/tests/compile-and-dump/Singletons/NegativeLiterals.golden
+++ b/tests/compile-and-dump/Singletons/NegativeLiterals.golden
@@ -11,11 +11,11 @@
     type F :: Natural
     type family F :: Natural where
       F = Negate (FromInteger 1)
-    sF :: Sing (FSym0 :: Natural)
+    sF :: (Sing (F :: Natural) :: Type)
     sF = sNegate (sFromInteger (sing :: Sing 1))
-
-Singletons/NegativeLiterals.hs:0:0: warning: [-Woverflowed-literals]
+Singletons/NegativeLiterals.hs:0:0: warning: [GHC-97441] [-Woverflowed-literals]
     Literal -1 is negative but Natural only supports positive numbers
   |
 8 | $(singletons [d|
   |  ^^^^^^^^^^^^^^^...
+
diff --git a/tests/compile-and-dump/Singletons/Operators.golden b/tests/compile-and-dump/Singletons/Operators.golden
--- a/tests/compile-and-dump/Singletons/Operators.golden
+++ b/tests/compile-and-dump/Singletons/Operators.golden
@@ -30,17 +30,17 @@
       where
         (::+:@#@$###) :: SameKind (Apply (:+:@#@$) arg) ((:+:@#@$$) arg) =>
                          (:+:@#@$) a0123456789876543210
-    type instance Apply (:+:@#@$) a0123456789876543210 = (:+:@#@$$) a0123456789876543210
+    type instance Apply @Foo @((~>) Foo Foo) (:+:@#@$) a0123456789876543210 = (:+:@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:+:@#@$) where
-      suppressUnusedWarnings = snd (((,) (::+:@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (::+:@#@$###) ())
     type (:+:@#@$$) :: Foo -> (~>) Foo Foo
     data (:+:@#@$$) (a0123456789876543210 :: Foo) :: (~>) Foo Foo
       where
         (::+:@#@$$###) :: SameKind (Apply ((:+:@#@$$) a0123456789876543210) arg) ((:+:@#@$$$) a0123456789876543210 arg) =>
                           (:+:@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:+:@#@$$) a0123456789876543210) a0123456789876543210 = (:+:) a0123456789876543210 a0123456789876543210
+    type instance Apply @Foo @Foo ((:+:@#@$$) a0123456789876543210) a0123456789876543210 = (:+:) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:+:@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::+:@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (::+:@#@$$###) ())
     type (:+:@#@$$$) :: Foo -> Foo -> Foo
     type family (:+:@#@$$$) (a0123456789876543210 :: Foo) (a0123456789876543210 :: Foo) :: Foo where
       (:+:@#@$$$) a0123456789876543210 a0123456789876543210 = (:+:) a0123456789876543210 a0123456789876543210
@@ -49,17 +49,17 @@
       where
         (:+@#@$###) :: SameKind (Apply (+@#@$) arg) ((+@#@$$) arg) =>
                        (+@#@$) a0123456789876543210
-    type instance Apply (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210
+    type instance Apply @Nat @((~>) Nat Nat) (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (+@#@$) where
-      suppressUnusedWarnings = snd (((,) (:+@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (:+@#@$###) ())
     type (+@#@$$) :: Nat -> (~>) Nat Nat
     data (+@#@$$) (a0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
         (:+@#@$$###) :: SameKind (Apply ((+@#@$$) a0123456789876543210) arg) ((+@#@$$$) a0123456789876543210 arg) =>
                         (+@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((+@#@$$) a0123456789876543210) a0123456789876543210 = (+) a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat ((+@#@$$) a0123456789876543210) a0123456789876543210 = (+) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((+@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:+@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (:+@#@$$###) ())
     type (+@#@$$$) :: Nat -> Nat -> Nat
     type family (+@#@$$$) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
       (+@#@$$$) a0123456789876543210 a0123456789876543210 = (+) a0123456789876543210 a0123456789876543210
@@ -68,9 +68,9 @@
       where
         ChildSym0KindInference :: SameKind (Apply ChildSym0 arg) (ChildSym1 arg) =>
                                   ChildSym0 a0123456789876543210
-    type instance Apply ChildSym0 a0123456789876543210 = Child a0123456789876543210
+    type instance Apply @Foo @Foo ChildSym0 a0123456789876543210 = Child a0123456789876543210
     instance SuppressUnusedWarnings ChildSym0 where
-      suppressUnusedWarnings = snd (((,) ChildSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) ChildSym0KindInference ())
     type ChildSym1 :: Foo -> Foo
     type family ChildSym1 (a0123456789876543210 :: Foo) :: Foo where
       ChildSym1 a0123456789876543210 = Child a0123456789876543210
@@ -83,26 +83,27 @@
       Child FLeaf = FLeafSym0
       Child ((:+:) a _) = a
     (%+) ::
-      forall (t :: Nat) (t :: Nat). Sing t
-                                    -> Sing t -> Sing (Apply (Apply (+@#@$) t) t :: Nat)
+      (forall (t :: Nat) (t :: Nat).
+       Sing t -> Sing t -> Sing ((+) t t :: Nat) :: Type)
     sChild ::
-      forall (t :: Foo). Sing t -> Sing (Apply ChildSym0 t :: Foo)
+      (forall (t :: Foo). Sing t -> Sing (Child t :: Foo) :: Type)
     (%+) SZero (sM :: Sing m) = sM
     (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)
-      = (applySing ((singFun1 @SuccSym0) SSucc))
-          ((applySing ((applySing ((singFun2 @(+@#@$)) (%+))) sN)) sM)
+      = applySing
+          (singFun1 @SuccSym0 SSucc)
+          (applySing (applySing (singFun2 @(+@#@$) (%+)) sN) sM)
     sChild SFLeaf = SFLeaf
     sChild ((:%+:) (sA :: Sing a) _) = sA
     instance SingI ((+@#@$) :: (~>) Nat ((~>) Nat Nat)) where
-      sing = (singFun2 @(+@#@$)) (%+)
+      sing = singFun2 @(+@#@$) (%+)
     instance SingI d =>
              SingI ((+@#@$$) (d :: Nat) :: (~>) Nat Nat) where
-      sing = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) (sing @d))
+      sing = singFun1 @((+@#@$$) (d :: Nat)) ((%+) (sing @d))
     instance SingI1 ((+@#@$$) :: Nat -> (~>) Nat Nat) where
       liftSing (s :: Sing (d :: Nat))
-        = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) s)
+        = singFun1 @((+@#@$$) (d :: Nat)) ((%+) s)
     instance SingI (ChildSym0 :: (~>) Foo Foo) where
-      sing = (singFun1 @ChildSym0) sChild
+      sing = singFun1 @ChildSym0 sChild
     data SFoo :: Foo -> Type
       where
         SFLeaf :: SFoo (FLeaf :: Foo)
@@ -112,27 +113,25 @@
     instance SingKind Foo where
       type Demote Foo = Foo
       fromSing SFLeaf = FLeaf
-      fromSing ((:%+:) b b) = ((:+:) (fromSing b)) (fromSing b)
+      fromSing ((:%+:) b b) = (:+:) (fromSing b) (fromSing b)
       toSing FLeaf = SomeSing SFLeaf
       toSing ((:+:) (b :: Demote Foo) (b :: Demote Foo))
-        = case
-              ((,) (toSing b :: SomeSing Foo)) (toSing b :: SomeSing Foo)
-          of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%+:) c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:%+:) c c))
+            (toSing b :: SomeSing Foo) (toSing b :: SomeSing Foo)
     instance SingI FLeaf where
       sing = SFLeaf
     instance (SingI n, SingI n) =>
              SingI ((:+:) (n :: Foo) (n :: Foo)) where
-      sing = ((:%+:) sing) sing
+      sing = (:%+:) sing sing
     instance SingI n => SingI1 ((:+:) (n :: Foo)) where
       liftSing = (:%+:) sing
     instance SingI2 (:+:) where
       liftSing2 = (:%+:)
     instance SingI ((:+:@#@$) :: (~>) Foo ((~>) Foo Foo)) where
-      sing = (singFun2 @(:+:@#@$)) (:%+:)
+      sing = singFun2 @(:+:@#@$) (:%+:)
     instance SingI d =>
              SingI ((:+:@#@$$) (d :: Foo) :: (~>) Foo Foo) where
-      sing = (singFun1 @((:+:@#@$$) (d :: Foo))) ((:%+:) (sing @d))
+      sing = singFun1 @((:+:@#@$$) (d :: Foo)) ((:%+:) (sing @d))
     instance SingI1 ((:+:@#@$$) :: Foo -> (~>) Foo Foo) where
       liftSing (s :: Sing (d :: Foo))
-        = (singFun1 @((:+:@#@$$) (d :: Foo))) ((:%+:) s)
+        = singFun1 @((:+:@#@$$) (d :: Foo)) ((:%+:) s)
diff --git a/tests/compile-and-dump/Singletons/OrdDeriving.golden b/tests/compile-and-dump/Singletons/OrdDeriving.golden
--- a/tests/compile-and-dump/Singletons/OrdDeriving.golden
+++ b/tests/compile-and-dump/Singletons/OrdDeriving.golden
@@ -31,1476 +31,1343 @@
       where
         SuccSym0KindInference :: SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>
                                  SuccSym0 a0123456789876543210
-    type instance Apply SuccSym0 a0123456789876543210 = Succ a0123456789876543210
-    instance SuppressUnusedWarnings SuccSym0 where
-      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())
-    type SuccSym1 :: Nat -> Nat
-    type family SuccSym1 (a0123456789876543210 :: Nat) :: Nat where
-      SuccSym1 a0123456789876543210 = Succ a0123456789876543210
-    type ASym0 :: forall a
-                         b
-                         c
-                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-    data ASym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-      where
-        ASym0KindInference :: SameKind (Apply ASym0 arg) (ASym1 arg) =>
-                              ASym0 a0123456789876543210
-    type instance Apply ASym0 a0123456789876543210 = ASym1 a0123456789876543210
-    instance SuppressUnusedWarnings ASym0 where
-      suppressUnusedWarnings = snd (((,) ASym0KindInference) ())
-    type ASym1 :: forall a b c d. a
-                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
-    data ASym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
-      where
-        ASym1KindInference :: SameKind (Apply (ASym1 a0123456789876543210) arg) (ASym2 a0123456789876543210 arg) =>
-                              ASym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ASym1 a0123456789876543210) a0123456789876543210 = ASym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ASym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ASym1KindInference) ())
-    type ASym2 :: forall a b c d. a
-                                  -> b -> (~>) c ((~>) d (Foo a b c d))
-    data ASym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
-      where
-        ASym2KindInference :: SameKind (Apply (ASym2 a0123456789876543210 a0123456789876543210) arg) (ASym3 a0123456789876543210 a0123456789876543210 arg) =>
-                              ASym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ASym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ASym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ASym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ASym2KindInference) ())
-    type ASym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
-    data ASym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
-      where
-        ASym3KindInference :: SameKind (Apply (ASym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (ASym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
-                              ASym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ASym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = A a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ASym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ASym3KindInference) ())
-    type ASym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
-    type family ASym4 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
-      ASym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = A a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type BSym0 :: forall a
-                         b
-                         c
-                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-    data BSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-      where
-        BSym0KindInference :: SameKind (Apply BSym0 arg) (BSym1 arg) =>
-                              BSym0 a0123456789876543210
-    type instance Apply BSym0 a0123456789876543210 = BSym1 a0123456789876543210
-    instance SuppressUnusedWarnings BSym0 where
-      suppressUnusedWarnings = snd (((,) BSym0KindInference) ())
-    type BSym1 :: forall a b c d. a
-                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
-    data BSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
-      where
-        BSym1KindInference :: SameKind (Apply (BSym1 a0123456789876543210) arg) (BSym2 a0123456789876543210 arg) =>
-                              BSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (BSym1 a0123456789876543210) a0123456789876543210 = BSym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (BSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BSym1KindInference) ())
-    type BSym2 :: forall a b c d. a
-                                  -> b -> (~>) c ((~>) d (Foo a b c d))
-    data BSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
-      where
-        BSym2KindInference :: SameKind (Apply (BSym2 a0123456789876543210 a0123456789876543210) arg) (BSym3 a0123456789876543210 a0123456789876543210 arg) =>
-                              BSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (BSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = BSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (BSym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BSym2KindInference) ())
-    type BSym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
-    data BSym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
-      where
-        BSym3KindInference :: SameKind (Apply (BSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (BSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
-                              BSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (BSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = B a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (BSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BSym3KindInference) ())
-    type BSym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
-    type family BSym4 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
-      BSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = B a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type CSym0 :: forall a
-                         b
-                         c
-                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-    data CSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-      where
-        CSym0KindInference :: SameKind (Apply CSym0 arg) (CSym1 arg) =>
-                              CSym0 a0123456789876543210
-    type instance Apply CSym0 a0123456789876543210 = CSym1 a0123456789876543210
-    instance SuppressUnusedWarnings CSym0 where
-      suppressUnusedWarnings = snd (((,) CSym0KindInference) ())
-    type CSym1 :: forall a b c d. a
-                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
-    data CSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
-      where
-        CSym1KindInference :: SameKind (Apply (CSym1 a0123456789876543210) arg) (CSym2 a0123456789876543210 arg) =>
-                              CSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (CSym1 a0123456789876543210) a0123456789876543210 = CSym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (CSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) CSym1KindInference) ())
-    type CSym2 :: forall a b c d. a
-                                  -> b -> (~>) c ((~>) d (Foo a b c d))
-    data CSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
-      where
-        CSym2KindInference :: SameKind (Apply (CSym2 a0123456789876543210 a0123456789876543210) arg) (CSym3 a0123456789876543210 a0123456789876543210 arg) =>
-                              CSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (CSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = CSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (CSym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) CSym2KindInference) ())
-    type CSym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
-    data CSym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
-      where
-        CSym3KindInference :: SameKind (Apply (CSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (CSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
-                              CSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (CSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = C a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (CSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) CSym3KindInference) ())
-    type CSym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
-    type family CSym4 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
-      CSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = C a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type DSym0 :: forall a
-                         b
-                         c
-                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-    data DSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-      where
-        DSym0KindInference :: SameKind (Apply DSym0 arg) (DSym1 arg) =>
-                              DSym0 a0123456789876543210
-    type instance Apply DSym0 a0123456789876543210 = DSym1 a0123456789876543210
-    instance SuppressUnusedWarnings DSym0 where
-      suppressUnusedWarnings = snd (((,) DSym0KindInference) ())
-    type DSym1 :: forall a b c d. a
-                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
-    data DSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
-      where
-        DSym1KindInference :: SameKind (Apply (DSym1 a0123456789876543210) arg) (DSym2 a0123456789876543210 arg) =>
-                              DSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (DSym1 a0123456789876543210) a0123456789876543210 = DSym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (DSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) DSym1KindInference) ())
-    type DSym2 :: forall a b c d. a
-                                  -> b -> (~>) c ((~>) d (Foo a b c d))
-    data DSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
-      where
-        DSym2KindInference :: SameKind (Apply (DSym2 a0123456789876543210 a0123456789876543210) arg) (DSym3 a0123456789876543210 a0123456789876543210 arg) =>
-                              DSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (DSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = DSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (DSym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) DSym2KindInference) ())
-    type DSym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
-    data DSym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
-      where
-        DSym3KindInference :: SameKind (Apply (DSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (DSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
-                              DSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (DSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = D a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (DSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) DSym3KindInference) ())
-    type DSym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
-    type family DSym4 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
-      DSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = D a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type ESym0 :: forall a
-                         b
-                         c
-                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-    data ESym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-      where
-        ESym0KindInference :: SameKind (Apply ESym0 arg) (ESym1 arg) =>
-                              ESym0 a0123456789876543210
-    type instance Apply ESym0 a0123456789876543210 = ESym1 a0123456789876543210
-    instance SuppressUnusedWarnings ESym0 where
-      suppressUnusedWarnings = snd (((,) ESym0KindInference) ())
-    type ESym1 :: forall a b c d. a
-                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
-    data ESym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
-      where
-        ESym1KindInference :: SameKind (Apply (ESym1 a0123456789876543210) arg) (ESym2 a0123456789876543210 arg) =>
-                              ESym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ESym1 a0123456789876543210) a0123456789876543210 = ESym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ESym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ESym1KindInference) ())
-    type ESym2 :: forall a b c d. a
-                                  -> b -> (~>) c ((~>) d (Foo a b c d))
-    data ESym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
-      where
-        ESym2KindInference :: SameKind (Apply (ESym2 a0123456789876543210 a0123456789876543210) arg) (ESym3 a0123456789876543210 a0123456789876543210 arg) =>
-                              ESym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ESym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ESym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ESym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ESym2KindInference) ())
-    type ESym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
-    data ESym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
-      where
-        ESym3KindInference :: SameKind (Apply (ESym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (ESym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
-                              ESym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ESym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = E a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ESym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ESym3KindInference) ())
-    type ESym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
-    type family ESym4 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
-      ESym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = E a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type FSym0 :: forall a
-                         b
-                         c
-                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-    data FSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
-      where
-        FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
-                              FSym0 a0123456789876543210
-    type instance Apply FSym0 a0123456789876543210 = FSym1 a0123456789876543210
-    instance SuppressUnusedWarnings FSym0 where
-      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())
-    type FSym1 :: forall a b c d. a
-                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
-    data FSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
-      where
-        FSym1KindInference :: SameKind (Apply (FSym1 a0123456789876543210) arg) (FSym2 a0123456789876543210 arg) =>
-                              FSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FSym1 a0123456789876543210) a0123456789876543210 = FSym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (FSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FSym1KindInference) ())
-    type FSym2 :: forall a b c d. a
-                                  -> b -> (~>) c ((~>) d (Foo a b c d))
-    data FSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
-      where
-        FSym2KindInference :: SameKind (Apply (FSym2 a0123456789876543210 a0123456789876543210) arg) (FSym3 a0123456789876543210 a0123456789876543210 arg) =>
-                              FSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (FSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = FSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (FSym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FSym2KindInference) ())
-    type FSym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
-    data FSym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
-      where
-        FSym3KindInference :: SameKind (Apply (FSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (FSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
-                              FSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (FSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = F a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (FSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FSym3KindInference) ())
-    type FSym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
-    type family FSym4 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
-      FSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = F a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type TFHelper_0123456789876543210 :: Nat -> Nat -> Bool
-    type family TFHelper_0123456789876543210 (a :: Nat) (a :: Nat) :: Bool where
-      TFHelper_0123456789876543210 Zero Zero = TrueSym0
-      TFHelper_0123456789876543210 Zero (Succ _) = FalseSym0
-      TFHelper_0123456789876543210 (Succ _) Zero = FalseSym0
-      TFHelper_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
-    type TFHelper_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Nat -> (~>) Nat Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Nat -> Nat -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PEq Nat where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type Compare_0123456789876543210 :: Nat -> Nat -> Ordering
-    type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where
-      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
-      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
-      Compare_0123456789876543210 Zero (Succ _) = LTSym0
-      Compare_0123456789876543210 (Succ _) Zero = GTSym0
-    type Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: Nat -> (~>) Nat Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: Nat -> Nat -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance POrd Nat where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
-    type TFHelper_0123456789876543210 :: Foo a b c d
-                                         -> Foo a b c d -> Bool
-    type family TFHelper_0123456789876543210 (a :: Foo a b c d) (a :: Foo a b c d) :: Bool where
-      TFHelper_0123456789876543210 (A a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (A b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
-      TFHelper_0123456789876543210 (A _ _ _ _) (B _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (A _ _ _ _) (C _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (A _ _ _ _) (D _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (A _ _ _ _) (E _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (A _ _ _ _) (F _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (B _ _ _ _) (A _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (B a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (B b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
-      TFHelper_0123456789876543210 (B _ _ _ _) (C _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (B _ _ _ _) (D _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (B _ _ _ _) (E _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (B _ _ _ _) (F _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (C _ _ _ _) (A _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (C _ _ _ _) (B _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (C a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (C b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
-      TFHelper_0123456789876543210 (C _ _ _ _) (D _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (C _ _ _ _) (E _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (C _ _ _ _) (F _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (D _ _ _ _) (A _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (D _ _ _ _) (B _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (D _ _ _ _) (C _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (D a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (D b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
-      TFHelper_0123456789876543210 (D _ _ _ _) (E _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (D _ _ _ _) (F _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (E _ _ _ _) (A _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (E _ _ _ _) (B _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (E _ _ _ _) (C _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (E _ _ _ _) (D _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (E a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (E b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
-      TFHelper_0123456789876543210 (E _ _ _ _) (F _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (F _ _ _ _) (A _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (F _ _ _ _) (B _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (F _ _ _ _) (C _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (F _ _ _ _) (D _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (F _ _ _ _) (E _ _ _ _) = FalseSym0
-      TFHelper_0123456789876543210 (F a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (F b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
-    type TFHelper_0123456789876543210Sym0 :: (~>) (Foo a b c d) ((~>) (Foo a b c d) Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) (Foo a b c d) ((~>) (Foo a b c d) Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Foo a b c d
-                                             -> (~>) (Foo a b c d) Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Foo a b c d) :: (~>) (Foo a b c d) Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Foo a b c d
-                                             -> Foo a b c d -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Foo a b c d) (a0123456789876543210 :: Foo a b c d) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance PEq (Foo a b c d) where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type Compare_0123456789876543210 :: Foo a b c d
-                                        -> Foo a b c d -> Ordering
-    type family Compare_0123456789876543210 (a :: Foo a b c d) (a :: Foo a b c d) :: Ordering where
-      Compare_0123456789876543210 (A a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (A b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
-      Compare_0123456789876543210 (B a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (B b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
-      Compare_0123456789876543210 (C a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (C b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
-      Compare_0123456789876543210 (D a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (D b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
-      Compare_0123456789876543210 (E a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (E b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
-      Compare_0123456789876543210 (F a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (F b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
-      Compare_0123456789876543210 (A _ _ _ _) (B _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (A _ _ _ _) (C _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (A _ _ _ _) (D _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (A _ _ _ _) (E _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (A _ _ _ _) (F _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (B _ _ _ _) (A _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (B _ _ _ _) (C _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (B _ _ _ _) (D _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (B _ _ _ _) (E _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (B _ _ _ _) (F _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (C _ _ _ _) (A _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (C _ _ _ _) (B _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (C _ _ _ _) (D _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (C _ _ _ _) (E _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (C _ _ _ _) (F _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (D _ _ _ _) (A _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (D _ _ _ _) (B _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (D _ _ _ _) (C _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (D _ _ _ _) (E _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (D _ _ _ _) (F _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (E _ _ _ _) (A _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (E _ _ _ _) (B _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (E _ _ _ _) (C _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (E _ _ _ _) (D _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (E _ _ _ _) (F _ _ _ _) = LTSym0
-      Compare_0123456789876543210 (F _ _ _ _) (A _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (F _ _ _ _) (B _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (F _ _ _ _) (C _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (F _ _ _ _) (D _ _ _ _) = GTSym0
-      Compare_0123456789876543210 (F _ _ _ _) (E _ _ _ _) = GTSym0
-    type Compare_0123456789876543210Sym0 :: (~>) (Foo a b c d) ((~>) (Foo a b c d) Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) (Foo a b c d) ((~>) (Foo a b c d) Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: Foo a b c d
-                                            -> (~>) (Foo a b c d) Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Foo a b c d) :: (~>) (Foo a b c d) Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: Foo a b c d
-                                            -> Foo a b c d -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: Foo a b c d) (a0123456789876543210 :: Foo a b c d) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance POrd (Foo a b c d) where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
-    data SNat :: Nat -> Type
-      where
-        SZero :: SNat (Zero :: Nat)
-        SSucc :: forall (n :: Nat). (Sing n) -> SNat (Succ n :: Nat)
-    type instance Sing @Nat = SNat
-    instance SingKind Nat where
-      type Demote Nat = Nat
-      fromSing SZero = Zero
-      fromSing (SSucc b) = Succ (fromSing b)
-      toSing Zero = SomeSing SZero
-      toSing (Succ (b :: Demote Nat))
-        = case toSing b :: SomeSing Nat of SomeSing c -> SomeSing (SSucc c)
-    data SFoo :: forall a b c d. Foo a b c d -> Type
-      where
-        SA :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              SFoo (A n n n n :: Foo a b c d)
-        SB :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              SFoo (B n n n n :: Foo a b c d)
-        SC :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              SFoo (C n n n n :: Foo a b c d)
-        SD :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              SFoo (D n n n n :: Foo a b c d)
-        SE :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              SFoo (E n n n n :: Foo a b c d)
-        SF :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              (Sing n) ->
-              SFoo (F n n n n :: Foo a b c d)
-    type instance Sing @(Foo a b c d) = SFoo
-    instance (SingKind a, SingKind b, SingKind c, SingKind d) =>
-             SingKind (Foo a b c d) where
-      type Demote (Foo a b c d) = Foo (Demote a) (Demote b) (Demote c) (Demote d)
-      fromSing (SA b b b b)
-        = (((A (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)
-      fromSing (SB b b b b)
-        = (((B (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)
-      fromSing (SC b b b b)
-        = (((C (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)
-      fromSing (SD b b b b)
-        = (((D (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)
-      fromSing (SE b b b b)
-        = (((E (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)
-      fromSing (SF b b b b)
-        = (((F (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)
-      toSing
-        (A (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
-        = case
-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))
-                 (toSing b :: SomeSing c))
-                (toSing b :: SomeSing d)
-          of
-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
-              -> SomeSing ((((SA c) c) c) c)
-      toSing
-        (B (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
-        = case
-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))
-                 (toSing b :: SomeSing c))
-                (toSing b :: SomeSing d)
-          of
-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
-              -> SomeSing ((((SB c) c) c) c)
-      toSing
-        (C (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
-        = case
-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))
-                 (toSing b :: SomeSing c))
-                (toSing b :: SomeSing d)
-          of
-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
-              -> SomeSing ((((SC c) c) c) c)
-      toSing
-        (D (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
-        = case
-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))
-                 (toSing b :: SomeSing c))
-                (toSing b :: SomeSing d)
-          of
-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
-              -> SomeSing ((((SD c) c) c) c)
-      toSing
-        (E (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
-        = case
-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))
-                 (toSing b :: SomeSing c))
-                (toSing b :: SomeSing d)
-          of
-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
-              -> SomeSing ((((SE c) c) c) c)
-      toSing
-        (F (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
-        = case
-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))
-                 (toSing b :: SomeSing c))
-                (toSing b :: SomeSing d)
-          of
-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
-              -> SomeSing ((((SF c) c) c) c)
-    instance SEq Nat => SEq Nat where
-      (%==) ::
-        forall (t1 :: Nat) (t2 :: Nat). Sing t1
-                                        -> Sing t2
-                                           -> Sing (Apply (Apply ((==@#@$) :: TyFun Nat ((~>) Nat Bool)
-                                                                              -> Type) t1) t2)
-      (%==) SZero SZero = STrue
-      (%==) SZero (SSucc _) = SFalse
-      (%==) (SSucc _) SZero = SFalse
-      (%==)
-        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-            sB_0123456789876543210
-    instance SOrd Nat => SOrd Nat where
-      sCompare ::
-        forall (t1 :: Nat) (t2 :: Nat). Sing t1
-                                        -> Sing t2
-                                           -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering)
-                                                                                 -> Type) t1) t2)
-      sCompare SZero SZero
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            SNil
-      sCompare
-        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               SNil)
-      sCompare SZero (SSucc _) = SLT
-      sCompare (SSucc _) SZero = SGT
-    instance (SEq a, SEq b, SEq c, SEq d) => SEq (Foo a b c d) where
-      (%==) ::
-        forall (t1 :: Foo a b c d) (t2 :: Foo a b c d). Sing t1
-                                                        -> Sing t2
-                                                           -> Sing (Apply (Apply ((==@#@$) :: TyFun (Foo a b c d) ((~>) (Foo a b c d) Bool)
-                                                                                              -> Type) t1) t2)
-      (%==)
-        (SA (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SA (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                ((applySing
-                    ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                   sB_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                   ((applySing
-                       ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                      ((applySing
-                          ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                     sB_0123456789876543210)))
-      (%==) (SA _ _ _ _) (SB _ _ _ _) = SFalse
-      (%==) (SA _ _ _ _) (SC _ _ _ _) = SFalse
-      (%==) (SA _ _ _ _) (SD _ _ _ _) = SFalse
-      (%==) (SA _ _ _ _) (SE _ _ _ _) = SFalse
-      (%==) (SA _ _ _ _) (SF _ _ _ _) = SFalse
-      (%==) (SB _ _ _ _) (SA _ _ _ _) = SFalse
-      (%==)
-        (SB (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SB (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                ((applySing
-                    ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                   sB_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                   ((applySing
-                       ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                      ((applySing
-                          ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                     sB_0123456789876543210)))
-      (%==) (SB _ _ _ _) (SC _ _ _ _) = SFalse
-      (%==) (SB _ _ _ _) (SD _ _ _ _) = SFalse
-      (%==) (SB _ _ _ _) (SE _ _ _ _) = SFalse
-      (%==) (SB _ _ _ _) (SF _ _ _ _) = SFalse
-      (%==) (SC _ _ _ _) (SA _ _ _ _) = SFalse
-      (%==) (SC _ _ _ _) (SB _ _ _ _) = SFalse
-      (%==)
-        (SC (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SC (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                ((applySing
-                    ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                   sB_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                   ((applySing
-                       ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                      ((applySing
-                          ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                     sB_0123456789876543210)))
-      (%==) (SC _ _ _ _) (SD _ _ _ _) = SFalse
-      (%==) (SC _ _ _ _) (SE _ _ _ _) = SFalse
-      (%==) (SC _ _ _ _) (SF _ _ _ _) = SFalse
-      (%==) (SD _ _ _ _) (SA _ _ _ _) = SFalse
-      (%==) (SD _ _ _ _) (SB _ _ _ _) = SFalse
-      (%==) (SD _ _ _ _) (SC _ _ _ _) = SFalse
-      (%==)
-        (SD (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SD (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                ((applySing
-                    ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                   sB_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                   ((applySing
-                       ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                      ((applySing
-                          ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                     sB_0123456789876543210)))
-      (%==) (SD _ _ _ _) (SE _ _ _ _) = SFalse
-      (%==) (SD _ _ _ _) (SF _ _ _ _) = SFalse
-      (%==) (SE _ _ _ _) (SA _ _ _ _) = SFalse
-      (%==) (SE _ _ _ _) (SB _ _ _ _) = SFalse
-      (%==) (SE _ _ _ _) (SC _ _ _ _) = SFalse
-      (%==) (SE _ _ _ _) (SD _ _ _ _) = SFalse
-      (%==)
-        (SE (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SE (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                ((applySing
-                    ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                   sB_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                   ((applySing
-                       ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                      ((applySing
-                          ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                     sB_0123456789876543210)))
-      (%==) (SE _ _ _ _) (SF _ _ _ _) = SFalse
-      (%==) (SF _ _ _ _) (SA _ _ _ _) = SFalse
-      (%==) (SF _ _ _ _) (SB _ _ _ _) = SFalse
-      (%==) (SF _ _ _ _) (SC _ _ _ _) = SFalse
-      (%==) (SF _ _ _ _) (SD _ _ _ _) = SFalse
-      (%==) (SF _ _ _ _) (SE _ _ _ _) = SFalse
-      (%==)
-        (SF (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SF (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                ((applySing
-                    ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                   sB_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                   ((applySing
-                       ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                      ((applySing
-                          ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                     sB_0123456789876543210)))
-    instance (SOrd a, SOrd b, SOrd c, SOrd d) =>
-             SOrd (Foo a b c d) where
-      sCompare ::
-        forall (t1 :: Foo a b c d) (t2 :: Foo a b c d). Sing t1
-                                                        -> Sing t2
-                                                           -> Sing (Apply (Apply (CompareSym0 :: TyFun (Foo a b c d) ((~>) (Foo a b c d) Ordering)
-                                                                                                 -> Type) t1) t2)
-      sCompare
-        (SA (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SA (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(:@#@$)) SCons))
-                      ((applySing
-                          ((applySing ((singFun2 @CompareSym0) sCompare))
-                             sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(:@#@$)) SCons))
-                         ((applySing
-                             ((applySing ((singFun2 @CompareSym0) sCompare))
-                                sA_0123456789876543210))
-                            sB_0123456789876543210)))
-                     ((applySing
-                         ((applySing ((singFun2 @(:@#@$)) SCons))
-                            ((applySing
-                                ((applySing ((singFun2 @CompareSym0) sCompare))
-                                   sA_0123456789876543210))
-                               sB_0123456789876543210)))
-                        SNil))))
-      sCompare
-        (SB (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SB (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(:@#@$)) SCons))
-                      ((applySing
-                          ((applySing ((singFun2 @CompareSym0) sCompare))
-                             sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(:@#@$)) SCons))
-                         ((applySing
-                             ((applySing ((singFun2 @CompareSym0) sCompare))
-                                sA_0123456789876543210))
-                            sB_0123456789876543210)))
-                     ((applySing
-                         ((applySing ((singFun2 @(:@#@$)) SCons))
-                            ((applySing
-                                ((applySing ((singFun2 @CompareSym0) sCompare))
-                                   sA_0123456789876543210))
-                               sB_0123456789876543210)))
-                        SNil))))
-      sCompare
-        (SC (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SC (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(:@#@$)) SCons))
-                      ((applySing
-                          ((applySing ((singFun2 @CompareSym0) sCompare))
-                             sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(:@#@$)) SCons))
-                         ((applySing
-                             ((applySing ((singFun2 @CompareSym0) sCompare))
-                                sA_0123456789876543210))
-                            sB_0123456789876543210)))
-                     ((applySing
-                         ((applySing ((singFun2 @(:@#@$)) SCons))
-                            ((applySing
-                                ((applySing ((singFun2 @CompareSym0) sCompare))
-                                   sA_0123456789876543210))
-                               sB_0123456789876543210)))
-                        SNil))))
-      sCompare
-        (SD (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SD (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(:@#@$)) SCons))
-                      ((applySing
-                          ((applySing ((singFun2 @CompareSym0) sCompare))
-                             sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(:@#@$)) SCons))
-                         ((applySing
-                             ((applySing ((singFun2 @CompareSym0) sCompare))
-                                sA_0123456789876543210))
-                            sB_0123456789876543210)))
-                     ((applySing
-                         ((applySing ((singFun2 @(:@#@$)) SCons))
-                            ((applySing
-                                ((applySing ((singFun2 @CompareSym0) sCompare))
-                                   sA_0123456789876543210))
-                               sB_0123456789876543210)))
-                        SNil))))
-      sCompare
-        (SE (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SE (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(:@#@$)) SCons))
-                      ((applySing
-                          ((applySing ((singFun2 @CompareSym0) sCompare))
-                             sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(:@#@$)) SCons))
-                         ((applySing
-                             ((applySing ((singFun2 @CompareSym0) sCompare))
-                                sA_0123456789876543210))
-                            sB_0123456789876543210)))
-                     ((applySing
-                         ((applySing ((singFun2 @(:@#@$)) SCons))
-                            ((applySing
-                                ((applySing ((singFun2 @CompareSym0) sCompare))
-                                   sA_0123456789876543210))
-                               sB_0123456789876543210)))
-                        SNil))))
-      sCompare
-        (SF (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210)
-            (sA_0123456789876543210 :: Sing a_0123456789876543210))
-        (SF (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210)
-            (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(:@#@$)) SCons))
-                      ((applySing
-                          ((applySing ((singFun2 @CompareSym0) sCompare))
-                             sA_0123456789876543210))
-                         sB_0123456789876543210)))
-                  ((applySing
-                      ((applySing ((singFun2 @(:@#@$)) SCons))
-                         ((applySing
-                             ((applySing ((singFun2 @CompareSym0) sCompare))
-                                sA_0123456789876543210))
-                            sB_0123456789876543210)))
-                     ((applySing
-                         ((applySing ((singFun2 @(:@#@$)) SCons))
-                            ((applySing
-                                ((applySing ((singFun2 @CompareSym0) sCompare))
-                                   sA_0123456789876543210))
-                               sB_0123456789876543210)))
-                        SNil))))
-      sCompare (SA _ _ _ _) (SB _ _ _ _) = SLT
-      sCompare (SA _ _ _ _) (SC _ _ _ _) = SLT
-      sCompare (SA _ _ _ _) (SD _ _ _ _) = SLT
-      sCompare (SA _ _ _ _) (SE _ _ _ _) = SLT
-      sCompare (SA _ _ _ _) (SF _ _ _ _) = SLT
-      sCompare (SB _ _ _ _) (SA _ _ _ _) = SGT
-      sCompare (SB _ _ _ _) (SC _ _ _ _) = SLT
-      sCompare (SB _ _ _ _) (SD _ _ _ _) = SLT
-      sCompare (SB _ _ _ _) (SE _ _ _ _) = SLT
-      sCompare (SB _ _ _ _) (SF _ _ _ _) = SLT
-      sCompare (SC _ _ _ _) (SA _ _ _ _) = SGT
-      sCompare (SC _ _ _ _) (SB _ _ _ _) = SGT
-      sCompare (SC _ _ _ _) (SD _ _ _ _) = SLT
-      sCompare (SC _ _ _ _) (SE _ _ _ _) = SLT
-      sCompare (SC _ _ _ _) (SF _ _ _ _) = SLT
-      sCompare (SD _ _ _ _) (SA _ _ _ _) = SGT
-      sCompare (SD _ _ _ _) (SB _ _ _ _) = SGT
-      sCompare (SD _ _ _ _) (SC _ _ _ _) = SGT
-      sCompare (SD _ _ _ _) (SE _ _ _ _) = SLT
-      sCompare (SD _ _ _ _) (SF _ _ _ _) = SLT
-      sCompare (SE _ _ _ _) (SA _ _ _ _) = SGT
-      sCompare (SE _ _ _ _) (SB _ _ _ _) = SGT
-      sCompare (SE _ _ _ _) (SC _ _ _ _) = SGT
-      sCompare (SE _ _ _ _) (SD _ _ _ _) = SGT
-      sCompare (SE _ _ _ _) (SF _ _ _ _) = SLT
-      sCompare (SF _ _ _ _) (SA _ _ _ _) = SGT
-      sCompare (SF _ _ _ _) (SB _ _ _ _) = SGT
-      sCompare (SF _ _ _ _) (SC _ _ _ _) = SGT
-      sCompare (SF _ _ _ _) (SD _ _ _ _) = SGT
-      sCompare (SF _ _ _ _) (SE _ _ _ _) = SGT
-    instance SDecide Nat => SDecide Nat where
-      (%~) SZero SZero = Proved Refl
-      (%~) SZero (SSucc _) = Disproved (\ x -> case x of {})
-      (%~) (SSucc _) SZero = Disproved (\ x -> case x of {})
-      (%~) (SSucc a) (SSucc b)
-        = case ((%~) a) b of
-            Proved Refl -> Proved Refl
-            Disproved contra
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-    instance SDecide Nat =>
-             Data.Type.Equality.TestEquality (SNat :: Nat -> Type) where
-      Data.Type.Equality.testEquality
-        = Data.Singletons.Decide.decideEquality
-    instance SDecide Nat =>
-             Data.Type.Coercion.TestCoercion (SNat :: Nat -> Type) where
-      Data.Type.Coercion.testCoercion
-        = Data.Singletons.Decide.decideCoercion
-    instance (SDecide a, SDecide b, SDecide c, SDecide d) =>
-             SDecide (Foo a b c d) where
-      (%~) (SA a a a a) (SA b b b b)
-        = case
-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)
-          of
-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
-              -> Proved Refl
-            (,,,) (Disproved contra) _ _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ (Disproved contra) _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ (Disproved contra) _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ _ (Disproved contra)
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-      (%~) (SA _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SA _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SA _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SA _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SA _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SB _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SB a a a a) (SB b b b b)
-        = case
-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)
-          of
-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
-              -> Proved Refl
-            (,,,) (Disproved contra) _ _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ (Disproved contra) _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ (Disproved contra) _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ _ (Disproved contra)
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-      (%~) (SB _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SB _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SB _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SB _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SC _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SC _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SC a a a a) (SC b b b b)
-        = case
-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)
-          of
-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
-              -> Proved Refl
-            (,,,) (Disproved contra) _ _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ (Disproved contra) _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ (Disproved contra) _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ _ (Disproved contra)
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-      (%~) (SC _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SC _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SC _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SD _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SD _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SD _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SD a a a a) (SD b b b b)
-        = case
-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)
-          of
-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
-              -> Proved Refl
-            (,,,) (Disproved contra) _ _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ (Disproved contra) _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ (Disproved contra) _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ _ (Disproved contra)
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-      (%~) (SD _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SD _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SE _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SE _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SE _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SE _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SE a a a a) (SE b b b b)
-        = case
-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)
-          of
-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
-              -> Proved Refl
-            (,,,) (Disproved contra) _ _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ (Disproved contra) _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ (Disproved contra) _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ _ (Disproved contra)
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-      (%~) (SE _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SF _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SF _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SF _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SF _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SF _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of {})
-      (%~) (SF a a a a) (SF b b b b)
-        = case
-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)
-          of
-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
-              -> Proved Refl
-            (,,,) (Disproved contra) _ _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ (Disproved contra) _ _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ (Disproved contra) _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,,,) _ _ _ (Disproved contra)
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-    instance (SDecide a, SDecide b, SDecide c, SDecide d) =>
-             Data.Type.Equality.TestEquality (SFoo :: Foo a b c d -> Type) where
-      Data.Type.Equality.testEquality
-        = Data.Singletons.Decide.decideEquality
-    instance (SDecide a, SDecide b, SDecide c, SDecide d) =>
-             Data.Type.Coercion.TestCoercion (SFoo :: Foo a b c d -> Type) where
-      Data.Type.Coercion.testCoercion
-        = Data.Singletons.Decide.decideCoercion
-    instance SingI Zero where
-      sing = SZero
-    instance SingI n => SingI (Succ (n :: Nat)) where
-      sing = SSucc sing
-    instance SingI1 Succ where
-      liftSing = SSucc
-    instance SingI (SuccSym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @SuccSym0) SSucc
-    instance (SingI n, SingI n, SingI n, SingI n) =>
-             SingI (A (n :: a) (n :: b) (n :: c) (n :: d)) where
-      sing = (((SA sing) sing) sing) sing
-    instance (SingI n, SingI n, SingI n) =>
-             SingI1 (A (n :: a) (n :: b) (n :: c)) where
-      liftSing = ((SA sing) sing) sing
-    instance (SingI n, SingI n) => SingI2 (A (n :: a) (n :: b)) where
-      liftSing2 = (SA sing) sing
-    instance SingI (ASym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
-      sing = (singFun4 @ASym0) SA
-    instance SingI d =>
-             SingI (ASym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      sing = (singFun3 @(ASym1 (d :: a))) (SA (sing @d))
-    instance SingI1 (ASym1 :: a
-                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      liftSing (s :: Sing (d :: a)) = (singFun3 @(ASym1 (d :: a))) (SA s)
-    instance (SingI d, SingI d) =>
-             SingI (ASym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
-      sing
-        = (singFun2 @(ASym2 (d :: a) (d :: b))) ((SA (sing @d)) (sing @d))
-    instance SingI d =>
-             SingI1 (ASym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing (s :: Sing (d :: b))
-        = (singFun2 @(ASym2 (d :: a) (d :: b))) ((SA (sing @d)) s)
-    instance SingI2 (ASym2 :: a
-                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
-        = (singFun2 @(ASym2 (d :: a) (d :: b))) ((SA s) s)
-    instance (SingI d, SingI d, SingI d) =>
-             SingI (ASym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
-      sing
-        = (singFun1 @(ASym3 (d :: a) (d :: b) (d :: c)))
-            (((SA (sing @d)) (sing @d)) (sing @d))
-    instance (SingI d, SingI d) =>
-             SingI1 (ASym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
-      liftSing (s :: Sing (d :: c))
-        = (singFun1 @(ASym3 (d :: a) (d :: b) (d :: c)))
-            (((SA (sing @d)) (sing @d)) s)
-    instance SingI d =>
-             SingI2 (ASym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
-      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
-        = (singFun1 @(ASym3 (d :: a) (d :: b) (d :: c)))
-            (((SA (sing @d)) s) s)
-    instance (SingI n, SingI n, SingI n, SingI n) =>
-             SingI (B (n :: a) (n :: b) (n :: c) (n :: d)) where
-      sing = (((SB sing) sing) sing) sing
-    instance (SingI n, SingI n, SingI n) =>
-             SingI1 (B (n :: a) (n :: b) (n :: c)) where
-      liftSing = ((SB sing) sing) sing
-    instance (SingI n, SingI n) => SingI2 (B (n :: a) (n :: b)) where
-      liftSing2 = (SB sing) sing
-    instance SingI (BSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
-      sing = (singFun4 @BSym0) SB
-    instance SingI d =>
-             SingI (BSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      sing = (singFun3 @(BSym1 (d :: a))) (SB (sing @d))
-    instance SingI1 (BSym1 :: a
-                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      liftSing (s :: Sing (d :: a)) = (singFun3 @(BSym1 (d :: a))) (SB s)
-    instance (SingI d, SingI d) =>
-             SingI (BSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
-      sing
-        = (singFun2 @(BSym2 (d :: a) (d :: b))) ((SB (sing @d)) (sing @d))
-    instance SingI d =>
-             SingI1 (BSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing (s :: Sing (d :: b))
-        = (singFun2 @(BSym2 (d :: a) (d :: b))) ((SB (sing @d)) s)
-    instance SingI2 (BSym2 :: a
-                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
-        = (singFun2 @(BSym2 (d :: a) (d :: b))) ((SB s) s)
-    instance (SingI d, SingI d, SingI d) =>
-             SingI (BSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
-      sing
-        = (singFun1 @(BSym3 (d :: a) (d :: b) (d :: c)))
-            (((SB (sing @d)) (sing @d)) (sing @d))
-    instance (SingI d, SingI d) =>
-             SingI1 (BSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
-      liftSing (s :: Sing (d :: c))
-        = (singFun1 @(BSym3 (d :: a) (d :: b) (d :: c)))
-            (((SB (sing @d)) (sing @d)) s)
-    instance SingI d =>
-             SingI2 (BSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
-      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
-        = (singFun1 @(BSym3 (d :: a) (d :: b) (d :: c)))
-            (((SB (sing @d)) s) s)
-    instance (SingI n, SingI n, SingI n, SingI n) =>
-             SingI (C (n :: a) (n :: b) (n :: c) (n :: d)) where
-      sing = (((SC sing) sing) sing) sing
-    instance (SingI n, SingI n, SingI n) =>
-             SingI1 (C (n :: a) (n :: b) (n :: c)) where
-      liftSing = ((SC sing) sing) sing
-    instance (SingI n, SingI n) => SingI2 (C (n :: a) (n :: b)) where
-      liftSing2 = (SC sing) sing
-    instance SingI (CSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
-      sing = (singFun4 @CSym0) SC
-    instance SingI d =>
-             SingI (CSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      sing = (singFun3 @(CSym1 (d :: a))) (SC (sing @d))
-    instance SingI1 (CSym1 :: a
-                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      liftSing (s :: Sing (d :: a)) = (singFun3 @(CSym1 (d :: a))) (SC s)
-    instance (SingI d, SingI d) =>
-             SingI (CSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
-      sing
-        = (singFun2 @(CSym2 (d :: a) (d :: b))) ((SC (sing @d)) (sing @d))
-    instance SingI d =>
-             SingI1 (CSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing (s :: Sing (d :: b))
-        = (singFun2 @(CSym2 (d :: a) (d :: b))) ((SC (sing @d)) s)
-    instance SingI2 (CSym2 :: a
-                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
-        = (singFun2 @(CSym2 (d :: a) (d :: b))) ((SC s) s)
-    instance (SingI d, SingI d, SingI d) =>
-             SingI (CSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
-      sing
-        = (singFun1 @(CSym3 (d :: a) (d :: b) (d :: c)))
-            (((SC (sing @d)) (sing @d)) (sing @d))
-    instance (SingI d, SingI d) =>
-             SingI1 (CSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
-      liftSing (s :: Sing (d :: c))
-        = (singFun1 @(CSym3 (d :: a) (d :: b) (d :: c)))
-            (((SC (sing @d)) (sing @d)) s)
-    instance SingI d =>
-             SingI2 (CSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
-      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
-        = (singFun1 @(CSym3 (d :: a) (d :: b) (d :: c)))
-            (((SC (sing @d)) s) s)
-    instance (SingI n, SingI n, SingI n, SingI n) =>
-             SingI (D (n :: a) (n :: b) (n :: c) (n :: d)) where
-      sing = (((SD sing) sing) sing) sing
-    instance (SingI n, SingI n, SingI n) =>
-             SingI1 (D (n :: a) (n :: b) (n :: c)) where
-      liftSing = ((SD sing) sing) sing
-    instance (SingI n, SingI n) => SingI2 (D (n :: a) (n :: b)) where
-      liftSing2 = (SD sing) sing
-    instance SingI (DSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
-      sing = (singFun4 @DSym0) SD
-    instance SingI d =>
-             SingI (DSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      sing = (singFun3 @(DSym1 (d :: a))) (SD (sing @d))
-    instance SingI1 (DSym1 :: a
-                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      liftSing (s :: Sing (d :: a)) = (singFun3 @(DSym1 (d :: a))) (SD s)
-    instance (SingI d, SingI d) =>
-             SingI (DSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
-      sing
-        = (singFun2 @(DSym2 (d :: a) (d :: b))) ((SD (sing @d)) (sing @d))
-    instance SingI d =>
-             SingI1 (DSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing (s :: Sing (d :: b))
-        = (singFun2 @(DSym2 (d :: a) (d :: b))) ((SD (sing @d)) s)
-    instance SingI2 (DSym2 :: a
-                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
-        = (singFun2 @(DSym2 (d :: a) (d :: b))) ((SD s) s)
-    instance (SingI d, SingI d, SingI d) =>
-             SingI (DSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
-      sing
-        = (singFun1 @(DSym3 (d :: a) (d :: b) (d :: c)))
-            (((SD (sing @d)) (sing @d)) (sing @d))
-    instance (SingI d, SingI d) =>
-             SingI1 (DSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
-      liftSing (s :: Sing (d :: c))
-        = (singFun1 @(DSym3 (d :: a) (d :: b) (d :: c)))
-            (((SD (sing @d)) (sing @d)) s)
-    instance SingI d =>
-             SingI2 (DSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
-      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
-        = (singFun1 @(DSym3 (d :: a) (d :: b) (d :: c)))
-            (((SD (sing @d)) s) s)
-    instance (SingI n, SingI n, SingI n, SingI n) =>
-             SingI (E (n :: a) (n :: b) (n :: c) (n :: d)) where
-      sing = (((SE sing) sing) sing) sing
-    instance (SingI n, SingI n, SingI n) =>
-             SingI1 (E (n :: a) (n :: b) (n :: c)) where
-      liftSing = ((SE sing) sing) sing
-    instance (SingI n, SingI n) => SingI2 (E (n :: a) (n :: b)) where
-      liftSing2 = (SE sing) sing
-    instance SingI (ESym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
-      sing = (singFun4 @ESym0) SE
-    instance SingI d =>
-             SingI (ESym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      sing = (singFun3 @(ESym1 (d :: a))) (SE (sing @d))
-    instance SingI1 (ESym1 :: a
-                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      liftSing (s :: Sing (d :: a)) = (singFun3 @(ESym1 (d :: a))) (SE s)
-    instance (SingI d, SingI d) =>
-             SingI (ESym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
-      sing
-        = (singFun2 @(ESym2 (d :: a) (d :: b))) ((SE (sing @d)) (sing @d))
-    instance SingI d =>
-             SingI1 (ESym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing (s :: Sing (d :: b))
-        = (singFun2 @(ESym2 (d :: a) (d :: b))) ((SE (sing @d)) s)
-    instance SingI2 (ESym2 :: a
-                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
-        = (singFun2 @(ESym2 (d :: a) (d :: b))) ((SE s) s)
-    instance (SingI d, SingI d, SingI d) =>
-             SingI (ESym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
-      sing
-        = (singFun1 @(ESym3 (d :: a) (d :: b) (d :: c)))
-            (((SE (sing @d)) (sing @d)) (sing @d))
-    instance (SingI d, SingI d) =>
-             SingI1 (ESym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
-      liftSing (s :: Sing (d :: c))
-        = (singFun1 @(ESym3 (d :: a) (d :: b) (d :: c)))
-            (((SE (sing @d)) (sing @d)) s)
-    instance SingI d =>
-             SingI2 (ESym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
-      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
-        = (singFun1 @(ESym3 (d :: a) (d :: b) (d :: c)))
-            (((SE (sing @d)) s) s)
-    instance (SingI n, SingI n, SingI n, SingI n) =>
-             SingI (F (n :: a) (n :: b) (n :: c) (n :: d)) where
-      sing = (((SF sing) sing) sing) sing
-    instance (SingI n, SingI n, SingI n) =>
-             SingI1 (F (n :: a) (n :: b) (n :: c)) where
-      liftSing = ((SF sing) sing) sing
-    instance (SingI n, SingI n) => SingI2 (F (n :: a) (n :: b)) where
-      liftSing2 = (SF sing) sing
-    instance SingI (FSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
-      sing = (singFun4 @FSym0) SF
-    instance SingI d =>
-             SingI (FSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      sing = (singFun3 @(FSym1 (d :: a))) (SF (sing @d))
-    instance SingI1 (FSym1 :: a
-                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
-      liftSing (s :: Sing (d :: a)) = (singFun3 @(FSym1 (d :: a))) (SF s)
-    instance (SingI d, SingI d) =>
-             SingI (FSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
-      sing
-        = (singFun2 @(FSym2 (d :: a) (d :: b))) ((SF (sing @d)) (sing @d))
-    instance SingI d =>
-             SingI1 (FSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing (s :: Sing (d :: b))
-        = (singFun2 @(FSym2 (d :: a) (d :: b))) ((SF (sing @d)) s)
-    instance SingI2 (FSym2 :: a
-                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
-      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
-        = (singFun2 @(FSym2 (d :: a) (d :: b))) ((SF s) s)
-    instance (SingI d, SingI d, SingI d) =>
-             SingI (FSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
-      sing
-        = (singFun1 @(FSym3 (d :: a) (d :: b) (d :: c)))
-            (((SF (sing @d)) (sing @d)) (sing @d))
-    instance (SingI d, SingI d) =>
-             SingI1 (FSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
-      liftSing (s :: Sing (d :: c))
-        = (singFun1 @(FSym3 (d :: a) (d :: b) (d :: c)))
-            (((SF (sing @d)) (sing @d)) s)
-    instance SingI d =>
-             SingI2 (FSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
-      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
-        = (singFun1 @(FSym3 (d :: a) (d :: b) (d :: c)))
-            (((SF (sing @d)) s) s)
+    type instance Apply @Nat @Nat SuccSym0 a0123456789876543210 = Succ a0123456789876543210
+    instance SuppressUnusedWarnings SuccSym0 where
+      suppressUnusedWarnings = snd ((,) SuccSym0KindInference ())
+    type SuccSym1 :: Nat -> Nat
+    type family SuccSym1 (a0123456789876543210 :: Nat) :: Nat where
+      SuccSym1 a0123456789876543210 = Succ a0123456789876543210
+    type ASym0 :: forall a
+                         b
+                         c
+                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+    data ASym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+      where
+        ASym0KindInference :: SameKind (Apply ASym0 arg) (ASym1 arg) =>
+                              ASym0 a0123456789876543210
+    type instance Apply @a @((~>) b ((~>) c ((~>) d (Foo a b c d)))) ASym0 a0123456789876543210 = ASym1 a0123456789876543210
+    instance SuppressUnusedWarnings ASym0 where
+      suppressUnusedWarnings = snd ((,) ASym0KindInference ())
+    type ASym1 :: forall a b c d. a
+                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
+    data ASym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
+      where
+        ASym1KindInference :: SameKind (Apply (ASym1 a0123456789876543210) arg) (ASym2 a0123456789876543210 arg) =>
+                              ASym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @((~>) c ((~>) d (Foo a b c d))) (ASym1 a0123456789876543210) a0123456789876543210 = ASym2 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (ASym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) ASym1KindInference ())
+    type ASym2 :: forall a b c d. a
+                                  -> b -> (~>) c ((~>) d (Foo a b c d))
+    data ASym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
+      where
+        ASym2KindInference :: SameKind (Apply (ASym2 a0123456789876543210 a0123456789876543210) arg) (ASym3 a0123456789876543210 a0123456789876543210 arg) =>
+                              ASym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @c @((~>) d (Foo a b c d)) (ASym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ASym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (ASym2 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) ASym2KindInference ())
+    type ASym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
+    data ASym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
+      where
+        ASym3KindInference :: SameKind (Apply (ASym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (ASym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
+                              ASym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @d @(Foo a b c d) (ASym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = A a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (ASym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) ASym3KindInference ())
+    type ASym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
+    type family ASym4 @a @b @c @d (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
+      ASym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = A a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type BSym0 :: forall a
+                         b
+                         c
+                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+    data BSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+      where
+        BSym0KindInference :: SameKind (Apply BSym0 arg) (BSym1 arg) =>
+                              BSym0 a0123456789876543210
+    type instance Apply @a @((~>) b ((~>) c ((~>) d (Foo a b c d)))) BSym0 a0123456789876543210 = BSym1 a0123456789876543210
+    instance SuppressUnusedWarnings BSym0 where
+      suppressUnusedWarnings = snd ((,) BSym0KindInference ())
+    type BSym1 :: forall a b c d. a
+                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
+    data BSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
+      where
+        BSym1KindInference :: SameKind (Apply (BSym1 a0123456789876543210) arg) (BSym2 a0123456789876543210 arg) =>
+                              BSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @((~>) c ((~>) d (Foo a b c d))) (BSym1 a0123456789876543210) a0123456789876543210 = BSym2 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (BSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) BSym1KindInference ())
+    type BSym2 :: forall a b c d. a
+                                  -> b -> (~>) c ((~>) d (Foo a b c d))
+    data BSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
+      where
+        BSym2KindInference :: SameKind (Apply (BSym2 a0123456789876543210 a0123456789876543210) arg) (BSym3 a0123456789876543210 a0123456789876543210 arg) =>
+                              BSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @c @((~>) d (Foo a b c d)) (BSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = BSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (BSym2 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) BSym2KindInference ())
+    type BSym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
+    data BSym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
+      where
+        BSym3KindInference :: SameKind (Apply (BSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (BSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
+                              BSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @d @(Foo a b c d) (BSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = B a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (BSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) BSym3KindInference ())
+    type BSym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
+    type family BSym4 @a @b @c @d (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
+      BSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = B a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type CSym0 :: forall a
+                         b
+                         c
+                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+    data CSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+      where
+        CSym0KindInference :: SameKind (Apply CSym0 arg) (CSym1 arg) =>
+                              CSym0 a0123456789876543210
+    type instance Apply @a @((~>) b ((~>) c ((~>) d (Foo a b c d)))) CSym0 a0123456789876543210 = CSym1 a0123456789876543210
+    instance SuppressUnusedWarnings CSym0 where
+      suppressUnusedWarnings = snd ((,) CSym0KindInference ())
+    type CSym1 :: forall a b c d. a
+                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
+    data CSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
+      where
+        CSym1KindInference :: SameKind (Apply (CSym1 a0123456789876543210) arg) (CSym2 a0123456789876543210 arg) =>
+                              CSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @((~>) c ((~>) d (Foo a b c d))) (CSym1 a0123456789876543210) a0123456789876543210 = CSym2 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (CSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) CSym1KindInference ())
+    type CSym2 :: forall a b c d. a
+                                  -> b -> (~>) c ((~>) d (Foo a b c d))
+    data CSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
+      where
+        CSym2KindInference :: SameKind (Apply (CSym2 a0123456789876543210 a0123456789876543210) arg) (CSym3 a0123456789876543210 a0123456789876543210 arg) =>
+                              CSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @c @((~>) d (Foo a b c d)) (CSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = CSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (CSym2 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) CSym2KindInference ())
+    type CSym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
+    data CSym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
+      where
+        CSym3KindInference :: SameKind (Apply (CSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (CSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
+                              CSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @d @(Foo a b c d) (CSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = C a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (CSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) CSym3KindInference ())
+    type CSym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
+    type family CSym4 @a @b @c @d (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
+      CSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = C a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type DSym0 :: forall a
+                         b
+                         c
+                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+    data DSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+      where
+        DSym0KindInference :: SameKind (Apply DSym0 arg) (DSym1 arg) =>
+                              DSym0 a0123456789876543210
+    type instance Apply @a @((~>) b ((~>) c ((~>) d (Foo a b c d)))) DSym0 a0123456789876543210 = DSym1 a0123456789876543210
+    instance SuppressUnusedWarnings DSym0 where
+      suppressUnusedWarnings = snd ((,) DSym0KindInference ())
+    type DSym1 :: forall a b c d. a
+                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
+    data DSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
+      where
+        DSym1KindInference :: SameKind (Apply (DSym1 a0123456789876543210) arg) (DSym2 a0123456789876543210 arg) =>
+                              DSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @((~>) c ((~>) d (Foo a b c d))) (DSym1 a0123456789876543210) a0123456789876543210 = DSym2 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (DSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) DSym1KindInference ())
+    type DSym2 :: forall a b c d. a
+                                  -> b -> (~>) c ((~>) d (Foo a b c d))
+    data DSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
+      where
+        DSym2KindInference :: SameKind (Apply (DSym2 a0123456789876543210 a0123456789876543210) arg) (DSym3 a0123456789876543210 a0123456789876543210 arg) =>
+                              DSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @c @((~>) d (Foo a b c d)) (DSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = DSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (DSym2 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) DSym2KindInference ())
+    type DSym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
+    data DSym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
+      where
+        DSym3KindInference :: SameKind (Apply (DSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (DSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
+                              DSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @d @(Foo a b c d) (DSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = D a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (DSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) DSym3KindInference ())
+    type DSym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
+    type family DSym4 @a @b @c @d (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
+      DSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = D a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type ESym0 :: forall a
+                         b
+                         c
+                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+    data ESym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+      where
+        ESym0KindInference :: SameKind (Apply ESym0 arg) (ESym1 arg) =>
+                              ESym0 a0123456789876543210
+    type instance Apply @a @((~>) b ((~>) c ((~>) d (Foo a b c d)))) ESym0 a0123456789876543210 = ESym1 a0123456789876543210
+    instance SuppressUnusedWarnings ESym0 where
+      suppressUnusedWarnings = snd ((,) ESym0KindInference ())
+    type ESym1 :: forall a b c d. a
+                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
+    data ESym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
+      where
+        ESym1KindInference :: SameKind (Apply (ESym1 a0123456789876543210) arg) (ESym2 a0123456789876543210 arg) =>
+                              ESym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @((~>) c ((~>) d (Foo a b c d))) (ESym1 a0123456789876543210) a0123456789876543210 = ESym2 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (ESym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) ESym1KindInference ())
+    type ESym2 :: forall a b c d. a
+                                  -> b -> (~>) c ((~>) d (Foo a b c d))
+    data ESym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
+      where
+        ESym2KindInference :: SameKind (Apply (ESym2 a0123456789876543210 a0123456789876543210) arg) (ESym3 a0123456789876543210 a0123456789876543210 arg) =>
+                              ESym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @c @((~>) d (Foo a b c d)) (ESym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ESym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (ESym2 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) ESym2KindInference ())
+    type ESym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
+    data ESym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
+      where
+        ESym3KindInference :: SameKind (Apply (ESym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (ESym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
+                              ESym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @d @(Foo a b c d) (ESym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = E a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (ESym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) ESym3KindInference ())
+    type ESym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
+    type family ESym4 @a @b @c @d (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
+      ESym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = E a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type FSym0 :: forall a
+                         b
+                         c
+                         d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+    data FSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))
+      where
+        FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
+                              FSym0 a0123456789876543210
+    type instance Apply @a @((~>) b ((~>) c ((~>) d (Foo a b c d)))) FSym0 a0123456789876543210 = FSym1 a0123456789876543210
+    instance SuppressUnusedWarnings FSym0 where
+      suppressUnusedWarnings = snd ((,) FSym0KindInference ())
+    type FSym1 :: forall a b c d. a
+                                  -> (~>) b ((~>) c ((~>) d (Foo a b c d)))
+    data FSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))
+      where
+        FSym1KindInference :: SameKind (Apply (FSym1 a0123456789876543210) arg) (FSym2 a0123456789876543210 arg) =>
+                              FSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @((~>) c ((~>) d (Foo a b c d))) (FSym1 a0123456789876543210) a0123456789876543210 = FSym2 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (FSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) FSym1KindInference ())
+    type FSym2 :: forall a b c d. a
+                                  -> b -> (~>) c ((~>) d (Foo a b c d))
+    data FSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d))
+      where
+        FSym2KindInference :: SameKind (Apply (FSym2 a0123456789876543210 a0123456789876543210) arg) (FSym3 a0123456789876543210 a0123456789876543210 arg) =>
+                              FSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @c @((~>) d (Foo a b c d)) (FSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = FSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (FSym2 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) FSym2KindInference ())
+    type FSym3 :: forall a b c d. a -> b -> c -> (~>) d (Foo a b c d)
+    data FSym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) :: (~>) d (Foo a b c d)
+      where
+        FSym3KindInference :: SameKind (Apply (FSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (FSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) =>
+                              FSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @d @(Foo a b c d) (FSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = F a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (FSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) FSym3KindInference ())
+    type FSym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d
+    type family FSym4 @a @b @c @d (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where
+      FSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = F a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type TFHelper_0123456789876543210 :: Nat -> Nat -> Bool
+    type family TFHelper_0123456789876543210 (a :: Nat) (a :: Nat) :: Bool where
+      TFHelper_0123456789876543210 Zero Zero = TrueSym0
+      TFHelper_0123456789876543210 Zero (Succ _) = FalseSym0
+      TFHelper_0123456789876543210 (Succ _) Zero = FalseSym0
+      TFHelper_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
+    instance PEq Nat where
+      type (==) a a = TFHelper_0123456789876543210 a a
+    type Compare_0123456789876543210 :: Nat -> Nat -> Ordering
+    type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where
+      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
+      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
+      Compare_0123456789876543210 Zero (Succ _) = LTSym0
+      Compare_0123456789876543210 (Succ _) Zero = GTSym0
+    instance POrd Nat where
+      type Compare a a = Compare_0123456789876543210 a a
+    type TFHelper_0123456789876543210 :: forall a b c d. Foo a b c d
+                                                         -> Foo a b c d -> Bool
+    type family TFHelper_0123456789876543210 @a @b @c @d (a :: Foo a b c d) (a :: Foo a b c d) :: Bool where
+      TFHelper_0123456789876543210 @a @b @c @d (A a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (A b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
+      TFHelper_0123456789876543210 @a @b @c @d (A _ _ _ _ :: Foo a b c d) (B _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (A _ _ _ _ :: Foo a b c d) (C _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (A _ _ _ _ :: Foo a b c d) (D _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (A _ _ _ _ :: Foo a b c d) (E _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (A _ _ _ _ :: Foo a b c d) (F _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (B _ _ _ _ :: Foo a b c d) (A _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (B a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (B b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
+      TFHelper_0123456789876543210 @a @b @c @d (B _ _ _ _ :: Foo a b c d) (C _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (B _ _ _ _ :: Foo a b c d) (D _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (B _ _ _ _ :: Foo a b c d) (E _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (B _ _ _ _ :: Foo a b c d) (F _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (C _ _ _ _ :: Foo a b c d) (A _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (C _ _ _ _ :: Foo a b c d) (B _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (C a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (C b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
+      TFHelper_0123456789876543210 @a @b @c @d (C _ _ _ _ :: Foo a b c d) (D _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (C _ _ _ _ :: Foo a b c d) (E _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (C _ _ _ _ :: Foo a b c d) (F _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (D _ _ _ _ :: Foo a b c d) (A _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (D _ _ _ _ :: Foo a b c d) (B _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (D _ _ _ _ :: Foo a b c d) (C _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (D a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (D b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
+      TFHelper_0123456789876543210 @a @b @c @d (D _ _ _ _ :: Foo a b c d) (E _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (D _ _ _ _ :: Foo a b c d) (F _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (E _ _ _ _ :: Foo a b c d) (A _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (E _ _ _ _ :: Foo a b c d) (B _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (E _ _ _ _ :: Foo a b c d) (C _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (E _ _ _ _ :: Foo a b c d) (D _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (E a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (E b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
+      TFHelper_0123456789876543210 @a @b @c @d (E _ _ _ _ :: Foo a b c d) (F _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (F _ _ _ _ :: Foo a b c d) (A _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (F _ _ _ _ :: Foo a b c d) (B _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (F _ _ _ _ :: Foo a b c d) (C _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (F _ _ _ _ :: Foo a b c d) (D _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (F _ _ _ _ :: Foo a b c d) (E _ _ _ _ :: Foo a b c d) = FalseSym0
+      TFHelper_0123456789876543210 @a @b @c @d (F a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (F b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)))
+    instance PEq (Foo a b c d) where
+      type (==) a a = TFHelper_0123456789876543210 a a
+    type Compare_0123456789876543210 :: forall a b c d. Foo a b c d
+                                                        -> Foo a b c d -> Ordering
+    type family Compare_0123456789876543210 @a @b @c @d (a :: Foo a b c d) (a :: Foo a b c d) :: Ordering where
+      Compare_0123456789876543210 @a @b @c @d (A a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (A b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
+      Compare_0123456789876543210 @a @b @c @d (B a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (B b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
+      Compare_0123456789876543210 @a @b @c @d (C a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (C b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
+      Compare_0123456789876543210 @a @b @c @d (D a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (D b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
+      Compare_0123456789876543210 @a @b @c @d (E a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (E b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
+      Compare_0123456789876543210 @a @b @c @d (F a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 :: Foo a b c d) (F b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 :: Foo a b c d) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))))
+      Compare_0123456789876543210 @a @b @c @d (A _ _ _ _ :: Foo a b c d) (B _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (A _ _ _ _ :: Foo a b c d) (C _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (A _ _ _ _ :: Foo a b c d) (D _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (A _ _ _ _ :: Foo a b c d) (E _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (A _ _ _ _ :: Foo a b c d) (F _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (B _ _ _ _ :: Foo a b c d) (A _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (B _ _ _ _ :: Foo a b c d) (C _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (B _ _ _ _ :: Foo a b c d) (D _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (B _ _ _ _ :: Foo a b c d) (E _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (B _ _ _ _ :: Foo a b c d) (F _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (C _ _ _ _ :: Foo a b c d) (A _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (C _ _ _ _ :: Foo a b c d) (B _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (C _ _ _ _ :: Foo a b c d) (D _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (C _ _ _ _ :: Foo a b c d) (E _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (C _ _ _ _ :: Foo a b c d) (F _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (D _ _ _ _ :: Foo a b c d) (A _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (D _ _ _ _ :: Foo a b c d) (B _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (D _ _ _ _ :: Foo a b c d) (C _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (D _ _ _ _ :: Foo a b c d) (E _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (D _ _ _ _ :: Foo a b c d) (F _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (E _ _ _ _ :: Foo a b c d) (A _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (E _ _ _ _ :: Foo a b c d) (B _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (E _ _ _ _ :: Foo a b c d) (C _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (E _ _ _ _ :: Foo a b c d) (D _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (E _ _ _ _ :: Foo a b c d) (F _ _ _ _ :: Foo a b c d) = LTSym0
+      Compare_0123456789876543210 @a @b @c @d (F _ _ _ _ :: Foo a b c d) (A _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (F _ _ _ _ :: Foo a b c d) (B _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (F _ _ _ _ :: Foo a b c d) (C _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (F _ _ _ _ :: Foo a b c d) (D _ _ _ _ :: Foo a b c d) = GTSym0
+      Compare_0123456789876543210 @a @b @c @d (F _ _ _ _ :: Foo a b c d) (E _ _ _ _ :: Foo a b c d) = GTSym0
+    instance POrd (Foo a b c d) where
+      type Compare a a = Compare_0123456789876543210 a a
+    data SNat :: Nat -> Type
+      where
+        SZero :: SNat (Zero :: Nat)
+        SSucc :: forall (n :: Nat). (Sing n) -> SNat (Succ n :: Nat)
+    type instance Sing @Nat = SNat
+    instance SingKind Nat where
+      type Demote Nat = Nat
+      fromSing SZero = Zero
+      fromSing (SSucc b) = Succ (fromSing b)
+      toSing Zero = SomeSing SZero
+      toSing (Succ (b :: Demote Nat))
+        = (\cases (SomeSing c) -> SomeSing (SSucc c))
+            (toSing b :: SomeSing Nat)
+    data SFoo :: forall a b c d. Foo a b c d -> Type
+      where
+        SA :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              SFoo (A n n n n :: Foo a b c d)
+        SB :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              SFoo (B n n n n :: Foo a b c d)
+        SC :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              SFoo (C n n n n :: Foo a b c d)
+        SD :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              SFoo (D n n n n :: Foo a b c d)
+        SE :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              SFoo (E n n n n :: Foo a b c d)
+        SF :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              (Sing n) ->
+              SFoo (F n n n n :: Foo a b c d)
+    type instance Sing @(Foo a b c d) = SFoo
+    instance (SingKind a, SingKind b, SingKind c, SingKind d) =>
+             SingKind (Foo a b c d) where
+      type Demote (Foo a b c d) = Foo (Demote a) (Demote b) (Demote c) (Demote d)
+      fromSing (SA b b b b)
+        = A (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      fromSing (SB b b b b)
+        = B (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      fromSing (SC b b b b)
+        = C (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      fromSing (SD b b b b)
+        = D (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      fromSing (SE b b b b)
+        = E (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      fromSing (SF b b b b)
+        = F (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      toSing
+        (A (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
+        = (\cases
+             (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+               -> SomeSing (SA c c c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
+            (toSing b :: SomeSing c) (toSing b :: SomeSing d)
+      toSing
+        (B (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
+        = (\cases
+             (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+               -> SomeSing (SB c c c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
+            (toSing b :: SomeSing c) (toSing b :: SomeSing d)
+      toSing
+        (C (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
+        = (\cases
+             (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+               -> SomeSing (SC c c c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
+            (toSing b :: SomeSing c) (toSing b :: SomeSing d)
+      toSing
+        (D (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
+        = (\cases
+             (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+               -> SomeSing (SD c c c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
+            (toSing b :: SomeSing c) (toSing b :: SomeSing d)
+      toSing
+        (E (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
+        = (\cases
+             (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+               -> SomeSing (SE c c c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
+            (toSing b :: SomeSing c) (toSing b :: SomeSing d)
+      toSing
+        (F (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))
+        = (\cases
+             (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+               -> SomeSing (SF c c c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
+            (toSing b :: SomeSing c) (toSing b :: SomeSing d)
+    instance SEq Nat => SEq Nat where
+      (%==) SZero SZero = STrue
+      (%==) SZero (SSucc _) = SFalse
+      (%==) (SSucc _) SZero = SFalse
+      (%==)
+        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+            sB_0123456789876543210
+    instance SOrd Nat => SOrd Nat where
+      sCompare SZero SZero
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            SNil
+      sCompare
+        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               SNil)
+      sCompare SZero (SSucc _) = SLT
+      sCompare (SSucc _) SZero = SGT
+    instance (SEq a, SEq b, SEq c, SEq d) => SEq (Foo a b c d) where
+      (%==)
+        (SA (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SA (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @(&&@#@$) (%&&))
+               (applySing
+                  (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                  sB_0123456789876543210))
+            (applySing
+               (applySing
+                  (singFun2 @(&&@#@$) (%&&))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(&&@#@$) (%&&))
+                     (applySing
+                        (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210)))
+      (%==) (SA _ _ _ _) (SB _ _ _ _) = SFalse
+      (%==) (SA _ _ _ _) (SC _ _ _ _) = SFalse
+      (%==) (SA _ _ _ _) (SD _ _ _ _) = SFalse
+      (%==) (SA _ _ _ _) (SE _ _ _ _) = SFalse
+      (%==) (SA _ _ _ _) (SF _ _ _ _) = SFalse
+      (%==) (SB _ _ _ _) (SA _ _ _ _) = SFalse
+      (%==)
+        (SB (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SB (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @(&&@#@$) (%&&))
+               (applySing
+                  (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                  sB_0123456789876543210))
+            (applySing
+               (applySing
+                  (singFun2 @(&&@#@$) (%&&))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(&&@#@$) (%&&))
+                     (applySing
+                        (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210)))
+      (%==) (SB _ _ _ _) (SC _ _ _ _) = SFalse
+      (%==) (SB _ _ _ _) (SD _ _ _ _) = SFalse
+      (%==) (SB _ _ _ _) (SE _ _ _ _) = SFalse
+      (%==) (SB _ _ _ _) (SF _ _ _ _) = SFalse
+      (%==) (SC _ _ _ _) (SA _ _ _ _) = SFalse
+      (%==) (SC _ _ _ _) (SB _ _ _ _) = SFalse
+      (%==)
+        (SC (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SC (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @(&&@#@$) (%&&))
+               (applySing
+                  (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                  sB_0123456789876543210))
+            (applySing
+               (applySing
+                  (singFun2 @(&&@#@$) (%&&))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(&&@#@$) (%&&))
+                     (applySing
+                        (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210)))
+      (%==) (SC _ _ _ _) (SD _ _ _ _) = SFalse
+      (%==) (SC _ _ _ _) (SE _ _ _ _) = SFalse
+      (%==) (SC _ _ _ _) (SF _ _ _ _) = SFalse
+      (%==) (SD _ _ _ _) (SA _ _ _ _) = SFalse
+      (%==) (SD _ _ _ _) (SB _ _ _ _) = SFalse
+      (%==) (SD _ _ _ _) (SC _ _ _ _) = SFalse
+      (%==)
+        (SD (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SD (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @(&&@#@$) (%&&))
+               (applySing
+                  (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                  sB_0123456789876543210))
+            (applySing
+               (applySing
+                  (singFun2 @(&&@#@$) (%&&))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(&&@#@$) (%&&))
+                     (applySing
+                        (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210)))
+      (%==) (SD _ _ _ _) (SE _ _ _ _) = SFalse
+      (%==) (SD _ _ _ _) (SF _ _ _ _) = SFalse
+      (%==) (SE _ _ _ _) (SA _ _ _ _) = SFalse
+      (%==) (SE _ _ _ _) (SB _ _ _ _) = SFalse
+      (%==) (SE _ _ _ _) (SC _ _ _ _) = SFalse
+      (%==) (SE _ _ _ _) (SD _ _ _ _) = SFalse
+      (%==)
+        (SE (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SE (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @(&&@#@$) (%&&))
+               (applySing
+                  (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                  sB_0123456789876543210))
+            (applySing
+               (applySing
+                  (singFun2 @(&&@#@$) (%&&))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(&&@#@$) (%&&))
+                     (applySing
+                        (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210)))
+      (%==) (SE _ _ _ _) (SF _ _ _ _) = SFalse
+      (%==) (SF _ _ _ _) (SA _ _ _ _) = SFalse
+      (%==) (SF _ _ _ _) (SB _ _ _ _) = SFalse
+      (%==) (SF _ _ _ _) (SC _ _ _ _) = SFalse
+      (%==) (SF _ _ _ _) (SD _ _ _ _) = SFalse
+      (%==) (SF _ _ _ _) (SE _ _ _ _) = SFalse
+      (%==)
+        (SF (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SF (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @(&&@#@$) (%&&))
+               (applySing
+                  (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                  sB_0123456789876543210))
+            (applySing
+               (applySing
+                  (singFun2 @(&&@#@$) (%&&))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(&&@#@$) (%&&))
+                     (applySing
+                        (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                     sB_0123456789876543210)))
+    instance (SOrd a, SOrd b, SOrd c, SOrd d) =>
+             SOrd (Foo a b c d) where
+      sCompare
+        (SA (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SA (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(:@#@$) SCons)
+                     (applySing
+                        (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing
+                        (singFun2 @(:@#@$) SCons)
+                        (applySing
+                           (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                           sB_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun2 @(:@#@$) SCons)
+                           (applySing
+                              (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                              sB_0123456789876543210))
+                        SNil))))
+      sCompare
+        (SB (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SB (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(:@#@$) SCons)
+                     (applySing
+                        (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing
+                        (singFun2 @(:@#@$) SCons)
+                        (applySing
+                           (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                           sB_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun2 @(:@#@$) SCons)
+                           (applySing
+                              (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                              sB_0123456789876543210))
+                        SNil))))
+      sCompare
+        (SC (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SC (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(:@#@$) SCons)
+                     (applySing
+                        (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing
+                        (singFun2 @(:@#@$) SCons)
+                        (applySing
+                           (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                           sB_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun2 @(:@#@$) SCons)
+                           (applySing
+                              (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                              sB_0123456789876543210))
+                        SNil))))
+      sCompare
+        (SD (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SD (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(:@#@$) SCons)
+                     (applySing
+                        (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing
+                        (singFun2 @(:@#@$) SCons)
+                        (applySing
+                           (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                           sB_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun2 @(:@#@$) SCons)
+                           (applySing
+                              (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                              sB_0123456789876543210))
+                        SNil))))
+      sCompare
+        (SE (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SE (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(:@#@$) SCons)
+                     (applySing
+                        (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing
+                        (singFun2 @(:@#@$) SCons)
+                        (applySing
+                           (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                           sB_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun2 @(:@#@$) SCons)
+                           (applySing
+                              (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                              sB_0123456789876543210))
+                        SNil))))
+      sCompare
+        (SF (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210)
+            (sA_0123456789876543210 :: Sing a_0123456789876543210))
+        (SF (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210)
+            (sB_0123456789876543210 :: Sing b_0123456789876543210))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(:@#@$) SCons)
+                     (applySing
+                        (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                        sB_0123456789876543210))
+                  (applySing
+                     (applySing
+                        (singFun2 @(:@#@$) SCons)
+                        (applySing
+                           (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                           sB_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun2 @(:@#@$) SCons)
+                           (applySing
+                              (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                              sB_0123456789876543210))
+                        SNil))))
+      sCompare (SA _ _ _ _) (SB _ _ _ _) = SLT
+      sCompare (SA _ _ _ _) (SC _ _ _ _) = SLT
+      sCompare (SA _ _ _ _) (SD _ _ _ _) = SLT
+      sCompare (SA _ _ _ _) (SE _ _ _ _) = SLT
+      sCompare (SA _ _ _ _) (SF _ _ _ _) = SLT
+      sCompare (SB _ _ _ _) (SA _ _ _ _) = SGT
+      sCompare (SB _ _ _ _) (SC _ _ _ _) = SLT
+      sCompare (SB _ _ _ _) (SD _ _ _ _) = SLT
+      sCompare (SB _ _ _ _) (SE _ _ _ _) = SLT
+      sCompare (SB _ _ _ _) (SF _ _ _ _) = SLT
+      sCompare (SC _ _ _ _) (SA _ _ _ _) = SGT
+      sCompare (SC _ _ _ _) (SB _ _ _ _) = SGT
+      sCompare (SC _ _ _ _) (SD _ _ _ _) = SLT
+      sCompare (SC _ _ _ _) (SE _ _ _ _) = SLT
+      sCompare (SC _ _ _ _) (SF _ _ _ _) = SLT
+      sCompare (SD _ _ _ _) (SA _ _ _ _) = SGT
+      sCompare (SD _ _ _ _) (SB _ _ _ _) = SGT
+      sCompare (SD _ _ _ _) (SC _ _ _ _) = SGT
+      sCompare (SD _ _ _ _) (SE _ _ _ _) = SLT
+      sCompare (SD _ _ _ _) (SF _ _ _ _) = SLT
+      sCompare (SE _ _ _ _) (SA _ _ _ _) = SGT
+      sCompare (SE _ _ _ _) (SB _ _ _ _) = SGT
+      sCompare (SE _ _ _ _) (SC _ _ _ _) = SGT
+      sCompare (SE _ _ _ _) (SD _ _ _ _) = SGT
+      sCompare (SE _ _ _ _) (SF _ _ _ _) = SLT
+      sCompare (SF _ _ _ _) (SA _ _ _ _) = SGT
+      sCompare (SF _ _ _ _) (SB _ _ _ _) = SGT
+      sCompare (SF _ _ _ _) (SC _ _ _ _) = SGT
+      sCompare (SF _ _ _ _) (SD _ _ _ _) = SGT
+      sCompare (SF _ _ _ _) (SE _ _ _ _) = SGT
+    instance SDecide Nat => SDecide Nat where
+      (%~) SZero SZero = Proved Refl
+      (%~) SZero (SSucc _) = Disproved (\case)
+      (%~) (SSucc _) SZero = Disproved (\case)
+      (%~) (SSucc a) (SSucc b)
+        = (\cases
+             (Proved Refl) -> Proved Refl
+             (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b)
+    instance Eq (SNat (z :: Nat)) where
+      (==) _ _ = True
+    instance SDecide Nat =>
+             GHC.Internal.Data.Type.Equality.TestEquality (SNat :: Nat
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
+        = Data.Singletons.Decide.decideEquality
+    instance SDecide Nat =>
+             GHC.Internal.Data.Type.Coercion.TestCoercion (SNat :: Nat
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
+        = Data.Singletons.Decide.decideCoercion
+    instance (SDecide a, SDecide b, SDecide c, SDecide d) =>
+             SDecide (Foo a b c d) where
+      (%~) (SA a a a a) (SA b b b b)
+        = (\cases
+             (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
+               -> Proved Refl
+             (Disproved contra) _ _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ (Disproved contra) _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ (Disproved contra) _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ _ (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+      (%~) (SA _ _ _ _) (SB _ _ _ _) = Disproved (\case)
+      (%~) (SA _ _ _ _) (SC _ _ _ _) = Disproved (\case)
+      (%~) (SA _ _ _ _) (SD _ _ _ _) = Disproved (\case)
+      (%~) (SA _ _ _ _) (SE _ _ _ _) = Disproved (\case)
+      (%~) (SA _ _ _ _) (SF _ _ _ _) = Disproved (\case)
+      (%~) (SB _ _ _ _) (SA _ _ _ _) = Disproved (\case)
+      (%~) (SB a a a a) (SB b b b b)
+        = (\cases
+             (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
+               -> Proved Refl
+             (Disproved contra) _ _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ (Disproved contra) _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ (Disproved contra) _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ _ (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+      (%~) (SB _ _ _ _) (SC _ _ _ _) = Disproved (\case)
+      (%~) (SB _ _ _ _) (SD _ _ _ _) = Disproved (\case)
+      (%~) (SB _ _ _ _) (SE _ _ _ _) = Disproved (\case)
+      (%~) (SB _ _ _ _) (SF _ _ _ _) = Disproved (\case)
+      (%~) (SC _ _ _ _) (SA _ _ _ _) = Disproved (\case)
+      (%~) (SC _ _ _ _) (SB _ _ _ _) = Disproved (\case)
+      (%~) (SC a a a a) (SC b b b b)
+        = (\cases
+             (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
+               -> Proved Refl
+             (Disproved contra) _ _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ (Disproved contra) _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ (Disproved contra) _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ _ (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+      (%~) (SC _ _ _ _) (SD _ _ _ _) = Disproved (\case)
+      (%~) (SC _ _ _ _) (SE _ _ _ _) = Disproved (\case)
+      (%~) (SC _ _ _ _) (SF _ _ _ _) = Disproved (\case)
+      (%~) (SD _ _ _ _) (SA _ _ _ _) = Disproved (\case)
+      (%~) (SD _ _ _ _) (SB _ _ _ _) = Disproved (\case)
+      (%~) (SD _ _ _ _) (SC _ _ _ _) = Disproved (\case)
+      (%~) (SD a a a a) (SD b b b b)
+        = (\cases
+             (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
+               -> Proved Refl
+             (Disproved contra) _ _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ (Disproved contra) _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ (Disproved contra) _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ _ (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+      (%~) (SD _ _ _ _) (SE _ _ _ _) = Disproved (\case)
+      (%~) (SD _ _ _ _) (SF _ _ _ _) = Disproved (\case)
+      (%~) (SE _ _ _ _) (SA _ _ _ _) = Disproved (\case)
+      (%~) (SE _ _ _ _) (SB _ _ _ _) = Disproved (\case)
+      (%~) (SE _ _ _ _) (SC _ _ _ _) = Disproved (\case)
+      (%~) (SE _ _ _ _) (SD _ _ _ _) = Disproved (\case)
+      (%~) (SE a a a a) (SE b b b b)
+        = (\cases
+             (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
+               -> Proved Refl
+             (Disproved contra) _ _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ (Disproved contra) _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ (Disproved contra) _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ _ (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+      (%~) (SE _ _ _ _) (SF _ _ _ _) = Disproved (\case)
+      (%~) (SF _ _ _ _) (SA _ _ _ _) = Disproved (\case)
+      (%~) (SF _ _ _ _) (SB _ _ _ _) = Disproved (\case)
+      (%~) (SF _ _ _ _) (SC _ _ _ _) = Disproved (\case)
+      (%~) (SF _ _ _ _) (SD _ _ _ _) = Disproved (\case)
+      (%~) (SF _ _ _ _) (SE _ _ _ _) = Disproved (\case)
+      (%~) (SF a a a a) (SF b b b b)
+        = (\cases
+             (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)
+               -> Proved Refl
+             (Disproved contra) _ _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ (Disproved contra) _ _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ (Disproved contra) _ -> Disproved (\cases Refl -> contra Refl)
+             _ _ _ (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+    instance Eq (SFoo (z :: Foo a b c d)) where
+      (==) _ _ = True
+    instance (SDecide a, SDecide b, SDecide c, SDecide d) =>
+             GHC.Internal.Data.Type.Equality.TestEquality (SFoo :: Foo a b c d
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
+        = Data.Singletons.Decide.decideEquality
+    instance (SDecide a, SDecide b, SDecide c, SDecide d) =>
+             GHC.Internal.Data.Type.Coercion.TestCoercion (SFoo :: Foo a b c d
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
+        = Data.Singletons.Decide.decideCoercion
+    instance Ord (SNat (z :: Nat)) where
+      compare _ _ = EQ
+    instance Ord (SFoo (z :: Foo a b c d)) where
+      compare _ _ = EQ
+    instance SingI Zero where
+      sing = SZero
+    instance SingI n => SingI (Succ (n :: Nat)) where
+      sing = SSucc sing
+    instance SingI1 Succ where
+      liftSing = SSucc
+    instance SingI (SuccSym0 :: (~>) Nat Nat) where
+      sing = singFun1 @SuccSym0 SSucc
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (A (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SA sing sing sing sing
+    instance (SingI n, SingI n, SingI n) =>
+             SingI1 (A (n :: a) (n :: b) (n :: c)) where
+      liftSing = SA sing sing sing
+    instance (SingI n, SingI n) => SingI2 (A (n :: a) (n :: b)) where
+      liftSing2 = SA sing sing
+    instance SingI (ASym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
+      sing = singFun4 @ASym0 SA
+    instance SingI d =>
+             SingI (ASym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      sing = singFun3 @(ASym1 (d :: a)) (SA (sing @d))
+    instance SingI1 (ASym1 :: a
+                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      liftSing (s :: Sing (d :: a)) = singFun3 @(ASym1 (d :: a)) (SA s)
+    instance (SingI d, SingI d) =>
+             SingI (ASym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
+      sing = singFun2 @(ASym2 (d :: a) (d :: b)) (SA (sing @d) (sing @d))
+    instance SingI d =>
+             SingI1 (ASym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing (s :: Sing (d :: b))
+        = singFun2 @(ASym2 (d :: a) (d :: b)) (SA (sing @d) s)
+    instance SingI2 (ASym2 :: a
+                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
+        = singFun2 @(ASym2 (d :: a) (d :: b)) (SA s s)
+    instance (SingI d, SingI d, SingI d) =>
+             SingI (ASym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
+      sing
+        = singFun1
+            @(ASym3 (d :: a) (d :: b) (d :: c))
+            (SA (sing @d) (sing @d) (sing @d))
+    instance (SingI d, SingI d) =>
+             SingI1 (ASym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
+      liftSing (s :: Sing (d :: c))
+        = singFun1
+            @(ASym3 (d :: a) (d :: b) (d :: c)) (SA (sing @d) (sing @d) s)
+    instance SingI d =>
+             SingI2 (ASym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
+      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
+        = singFun1 @(ASym3 (d :: a) (d :: b) (d :: c)) (SA (sing @d) s s)
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (B (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SB sing sing sing sing
+    instance (SingI n, SingI n, SingI n) =>
+             SingI1 (B (n :: a) (n :: b) (n :: c)) where
+      liftSing = SB sing sing sing
+    instance (SingI n, SingI n) => SingI2 (B (n :: a) (n :: b)) where
+      liftSing2 = SB sing sing
+    instance SingI (BSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
+      sing = singFun4 @BSym0 SB
+    instance SingI d =>
+             SingI (BSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      sing = singFun3 @(BSym1 (d :: a)) (SB (sing @d))
+    instance SingI1 (BSym1 :: a
+                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      liftSing (s :: Sing (d :: a)) = singFun3 @(BSym1 (d :: a)) (SB s)
+    instance (SingI d, SingI d) =>
+             SingI (BSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
+      sing = singFun2 @(BSym2 (d :: a) (d :: b)) (SB (sing @d) (sing @d))
+    instance SingI d =>
+             SingI1 (BSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing (s :: Sing (d :: b))
+        = singFun2 @(BSym2 (d :: a) (d :: b)) (SB (sing @d) s)
+    instance SingI2 (BSym2 :: a
+                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
+        = singFun2 @(BSym2 (d :: a) (d :: b)) (SB s s)
+    instance (SingI d, SingI d, SingI d) =>
+             SingI (BSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
+      sing
+        = singFun1
+            @(BSym3 (d :: a) (d :: b) (d :: c))
+            (SB (sing @d) (sing @d) (sing @d))
+    instance (SingI d, SingI d) =>
+             SingI1 (BSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
+      liftSing (s :: Sing (d :: c))
+        = singFun1
+            @(BSym3 (d :: a) (d :: b) (d :: c)) (SB (sing @d) (sing @d) s)
+    instance SingI d =>
+             SingI2 (BSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
+      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
+        = singFun1 @(BSym3 (d :: a) (d :: b) (d :: c)) (SB (sing @d) s s)
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (C (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SC sing sing sing sing
+    instance (SingI n, SingI n, SingI n) =>
+             SingI1 (C (n :: a) (n :: b) (n :: c)) where
+      liftSing = SC sing sing sing
+    instance (SingI n, SingI n) => SingI2 (C (n :: a) (n :: b)) where
+      liftSing2 = SC sing sing
+    instance SingI (CSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
+      sing = singFun4 @CSym0 SC
+    instance SingI d =>
+             SingI (CSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      sing = singFun3 @(CSym1 (d :: a)) (SC (sing @d))
+    instance SingI1 (CSym1 :: a
+                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      liftSing (s :: Sing (d :: a)) = singFun3 @(CSym1 (d :: a)) (SC s)
+    instance (SingI d, SingI d) =>
+             SingI (CSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
+      sing = singFun2 @(CSym2 (d :: a) (d :: b)) (SC (sing @d) (sing @d))
+    instance SingI d =>
+             SingI1 (CSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing (s :: Sing (d :: b))
+        = singFun2 @(CSym2 (d :: a) (d :: b)) (SC (sing @d) s)
+    instance SingI2 (CSym2 :: a
+                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
+        = singFun2 @(CSym2 (d :: a) (d :: b)) (SC s s)
+    instance (SingI d, SingI d, SingI d) =>
+             SingI (CSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
+      sing
+        = singFun1
+            @(CSym3 (d :: a) (d :: b) (d :: c))
+            (SC (sing @d) (sing @d) (sing @d))
+    instance (SingI d, SingI d) =>
+             SingI1 (CSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
+      liftSing (s :: Sing (d :: c))
+        = singFun1
+            @(CSym3 (d :: a) (d :: b) (d :: c)) (SC (sing @d) (sing @d) s)
+    instance SingI d =>
+             SingI2 (CSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
+      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
+        = singFun1 @(CSym3 (d :: a) (d :: b) (d :: c)) (SC (sing @d) s s)
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (D (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SD sing sing sing sing
+    instance (SingI n, SingI n, SingI n) =>
+             SingI1 (D (n :: a) (n :: b) (n :: c)) where
+      liftSing = SD sing sing sing
+    instance (SingI n, SingI n) => SingI2 (D (n :: a) (n :: b)) where
+      liftSing2 = SD sing sing
+    instance SingI (DSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
+      sing = singFun4 @DSym0 SD
+    instance SingI d =>
+             SingI (DSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      sing = singFun3 @(DSym1 (d :: a)) (SD (sing @d))
+    instance SingI1 (DSym1 :: a
+                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      liftSing (s :: Sing (d :: a)) = singFun3 @(DSym1 (d :: a)) (SD s)
+    instance (SingI d, SingI d) =>
+             SingI (DSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
+      sing = singFun2 @(DSym2 (d :: a) (d :: b)) (SD (sing @d) (sing @d))
+    instance SingI d =>
+             SingI1 (DSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing (s :: Sing (d :: b))
+        = singFun2 @(DSym2 (d :: a) (d :: b)) (SD (sing @d) s)
+    instance SingI2 (DSym2 :: a
+                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
+        = singFun2 @(DSym2 (d :: a) (d :: b)) (SD s s)
+    instance (SingI d, SingI d, SingI d) =>
+             SingI (DSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
+      sing
+        = singFun1
+            @(DSym3 (d :: a) (d :: b) (d :: c))
+            (SD (sing @d) (sing @d) (sing @d))
+    instance (SingI d, SingI d) =>
+             SingI1 (DSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
+      liftSing (s :: Sing (d :: c))
+        = singFun1
+            @(DSym3 (d :: a) (d :: b) (d :: c)) (SD (sing @d) (sing @d) s)
+    instance SingI d =>
+             SingI2 (DSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
+      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
+        = singFun1 @(DSym3 (d :: a) (d :: b) (d :: c)) (SD (sing @d) s s)
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (E (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SE sing sing sing sing
+    instance (SingI n, SingI n, SingI n) =>
+             SingI1 (E (n :: a) (n :: b) (n :: c)) where
+      liftSing = SE sing sing sing
+    instance (SingI n, SingI n) => SingI2 (E (n :: a) (n :: b)) where
+      liftSing2 = SE sing sing
+    instance SingI (ESym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
+      sing = singFun4 @ESym0 SE
+    instance SingI d =>
+             SingI (ESym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      sing = singFun3 @(ESym1 (d :: a)) (SE (sing @d))
+    instance SingI1 (ESym1 :: a
+                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      liftSing (s :: Sing (d :: a)) = singFun3 @(ESym1 (d :: a)) (SE s)
+    instance (SingI d, SingI d) =>
+             SingI (ESym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
+      sing = singFun2 @(ESym2 (d :: a) (d :: b)) (SE (sing @d) (sing @d))
+    instance SingI d =>
+             SingI1 (ESym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing (s :: Sing (d :: b))
+        = singFun2 @(ESym2 (d :: a) (d :: b)) (SE (sing @d) s)
+    instance SingI2 (ESym2 :: a
+                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
+        = singFun2 @(ESym2 (d :: a) (d :: b)) (SE s s)
+    instance (SingI d, SingI d, SingI d) =>
+             SingI (ESym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
+      sing
+        = singFun1
+            @(ESym3 (d :: a) (d :: b) (d :: c))
+            (SE (sing @d) (sing @d) (sing @d))
+    instance (SingI d, SingI d) =>
+             SingI1 (ESym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
+      liftSing (s :: Sing (d :: c))
+        = singFun1
+            @(ESym3 (d :: a) (d :: b) (d :: c)) (SE (sing @d) (sing @d) s)
+    instance SingI d =>
+             SingI2 (ESym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
+      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
+        = singFun1 @(ESym3 (d :: a) (d :: b) (d :: c)) (SE (sing @d) s s)
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (F (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SF sing sing sing sing
+    instance (SingI n, SingI n, SingI n) =>
+             SingI1 (F (n :: a) (n :: b) (n :: c)) where
+      liftSing = SF sing sing sing
+    instance (SingI n, SingI n) => SingI2 (F (n :: a) (n :: b)) where
+      liftSing2 = SF sing sing
+    instance SingI (FSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where
+      sing = singFun4 @FSym0 SF
+    instance SingI d =>
+             SingI (FSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      sing = singFun3 @(FSym1 (d :: a)) (SF (sing @d))
+    instance SingI1 (FSym1 :: a
+                              -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where
+      liftSing (s :: Sing (d :: a)) = singFun3 @(FSym1 (d :: a)) (SF s)
+    instance (SingI d, SingI d) =>
+             SingI (FSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where
+      sing = singFun2 @(FSym2 (d :: a) (d :: b)) (SF (sing @d) (sing @d))
+    instance SingI d =>
+             SingI1 (FSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing (s :: Sing (d :: b))
+        = singFun2 @(FSym2 (d :: a) (d :: b)) (SF (sing @d) s)
+    instance SingI2 (FSym2 :: a
+                              -> b -> (~>) c ((~>) d (Foo a b c d))) where
+      liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
+        = singFun2 @(FSym2 (d :: a) (d :: b)) (SF s s)
+    instance (SingI d, SingI d, SingI d) =>
+             SingI (FSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where
+      sing
+        = singFun1
+            @(FSym3 (d :: a) (d :: b) (d :: c))
+            (SF (sing @d) (sing @d) (sing @d))
+    instance (SingI d, SingI d) =>
+             SingI1 (FSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where
+      liftSing (s :: Sing (d :: c))
+        = singFun1
+            @(FSym3 (d :: a) (d :: b) (d :: c)) (SF (sing @d) (sing @d) s)
+    instance SingI d =>
+             SingI2 (FSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where
+      liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c))
+        = singFun1 @(FSym3 (d :: a) (d :: b) (d :: c)) (SF (sing @d) s s)
diff --git a/tests/compile-and-dump/Singletons/OverloadedStrings.golden b/tests/compile-and-dump/Singletons/OverloadedStrings.golden
--- a/tests/compile-and-dump/Singletons/OverloadedStrings.golden
+++ b/tests/compile-and-dump/Singletons/OverloadedStrings.golden
@@ -17,9 +17,9 @@
       where
         SymIdSym0KindInference :: SameKind (Apply SymIdSym0 arg) (SymIdSym1 arg) =>
                                   SymIdSym0 a0123456789876543210
-    type instance Apply SymIdSym0 a0123456789876543210 = SymId a0123456789876543210
+    type instance Apply @Symbol @Symbol SymIdSym0 a0123456789876543210 = SymId a0123456789876543210
     instance SuppressUnusedWarnings SymIdSym0 where
-      suppressUnusedWarnings = snd (((,) SymIdSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SymIdSym0KindInference ())
     type SymIdSym1 :: Symbol -> Symbol
     type family SymIdSym1 (a0123456789876543210 :: Symbol) :: Symbol where
       SymIdSym1 a0123456789876543210 = SymId a0123456789876543210
@@ -29,12 +29,12 @@
     type SymId :: Symbol -> Symbol
     type family SymId (a :: Symbol) :: Symbol where
       SymId x = x
-    sFoo :: Sing (FooSym0 :: Symbol)
+    sFoo :: (Sing (Foo :: Symbol) :: Type)
     sSymId ::
-      forall (t :: Symbol). Sing t -> Sing (Apply SymIdSym0 t :: Symbol)
+      (forall (t :: Symbol). Sing t -> Sing (SymId t :: Symbol) :: Type)
     sFoo
-      = (applySing ((singFun1 @SymIdSym0) sSymId))
-          (sFromString (sing :: Sing "foo"))
+      = applySing
+          (singFun1 @SymIdSym0 sSymId) (sFromString (sing :: Sing "foo"))
     sSymId (sX :: Sing x) = sX
     instance SingI (SymIdSym0 :: (~>) Symbol Symbol) where
-      sing = (singFun1 @SymIdSym0) sSymId
+      sing = singFun1 @SymIdSym0 sSymId
diff --git a/tests/compile-and-dump/Singletons/PatternMatching.golden b/tests/compile-and-dump/Singletons/PatternMatching.golden
--- a/tests/compile-and-dump/Singletons/PatternMatching.golden
+++ b/tests/compile-and-dump/Singletons/PatternMatching.golden
@@ -12,8 +12,8 @@
     data Pair a b
       = Pair a b
       deriving Show
-    pr = (Pair (Succ Zero)) [Zero]
-    complex = (Pair ((Pair (Just Zero)) Zero)) False
+    pr = Pair (Succ Zero) [Zero]
+    complex = Pair (Pair (Just Zero) Zero) False
     tuple = (False, Just Zero, True)
     aList = [Zero, Succ Zero, Succ (Succ Zero)]
     type PairSym0 :: forall a b. (~>) a ((~>) b (Pair a b))
@@ -21,19 +21,19 @@
       where
         PairSym0KindInference :: SameKind (Apply PairSym0 arg) (PairSym1 arg) =>
                                  PairSym0 a0123456789876543210
-    type instance Apply PairSym0 a0123456789876543210 = PairSym1 a0123456789876543210
+    type instance Apply @a @((~>) b (Pair a b)) PairSym0 a0123456789876543210 = PairSym1 a0123456789876543210
     instance SuppressUnusedWarnings PairSym0 where
-      suppressUnusedWarnings = snd (((,) PairSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) PairSym0KindInference ())
     type PairSym1 :: forall a b. a -> (~>) b (Pair a b)
     data PairSym1 (a0123456789876543210 :: a) :: (~>) b (Pair a b)
       where
         PairSym1KindInference :: SameKind (Apply (PairSym1 a0123456789876543210) arg) (PairSym2 a0123456789876543210 arg) =>
                                  PairSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (PairSym1 a0123456789876543210) a0123456789876543210 = Pair a0123456789876543210 a0123456789876543210
+    type instance Apply @b @(Pair a b) (PairSym1 a0123456789876543210) a0123456789876543210 = Pair a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (PairSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) PairSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) PairSym1KindInference ())
     type PairSym2 :: forall a b. a -> b -> Pair a b
-    type family PairSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Pair a b where
+    type family PairSym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Pair a b where
       PairSym2 a0123456789876543210 a0123456789876543210 = Pair a0123456789876543210 a0123456789876543210
     type family AListSym0 where
       AListSym0 = AList
@@ -51,77 +51,53 @@
       Complex = Apply (Apply PairSym0 (Apply (Apply PairSym0 (Apply JustSym0 ZeroSym0)) ZeroSym0)) FalseSym0
     type family Pr where
       Pr = Apply (Apply PairSym0 (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:@#@$) ZeroSym0) NilSym0)
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> Pair a b -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Pair a b) (a :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210 p_0123456789876543210 (Pair arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Pair ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) (Pair a b) ((~>) Symbol Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (Pair a b) ((~>) Symbol Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> Pair a b -> (~>) Symbol Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Pair a b) :: (~>) Symbol Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> Pair a b -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Pair a b) (a0123456789876543210 :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type ShowsPrec_0123456789876543210 :: forall a
+                                                 b. GHC.Internal.Bignum.Natural.Natural
+                                                    -> Pair a b -> Symbol -> Symbol
+    type family ShowsPrec_0123456789876543210 @a @b (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Pair a b) (a :: Symbol) :: Symbol where
+      ShowsPrec_0123456789876543210 @a @b (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (Pair arg_0123456789876543210 arg_0123456789876543210 :: Pair a b) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Pair ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210
     instance PShow (Pair a b) where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
-    sAList :: Sing @_ AListSym0
-    sTuple :: Sing @_ TupleSym0
-    sComplex :: Sing @_ ComplexSym0
-    sPr :: Sing @_ PrSym0
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
+    sAList :: Sing @_ AList
+    sTuple :: Sing @_ Tuple
+    sComplex :: Sing @_ Complex
+    sPr :: Sing @_ Pr
     sAList
-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))
-          ((applySing
-              ((applySing ((singFun2 @(:@#@$)) SCons))
-                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
-             ((applySing
-                 ((applySing ((singFun2 @(:@#@$)) SCons))
-                    ((applySing ((singFun1 @SuccSym0) SSucc))
-                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))
+      = applySing
+          (applySing (singFun2 @(:@#@$) SCons) SZero)
+          (applySing
+             (applySing
+                (singFun2 @(:@#@$) SCons)
+                (applySing (singFun1 @SuccSym0 SSucc) SZero))
+             (applySing
+                (applySing
+                   (singFun2 @(:@#@$) SCons)
+                   (applySing
+                      (singFun1 @SuccSym0 SSucc)
+                      (applySing (singFun1 @SuccSym0 SSucc) SZero)))
                 SNil))
     sTuple
-      = (applySing
-           ((applySing ((applySing ((singFun3 @Tuple3Sym0) STuple3)) SFalse))
-              ((applySing ((singFun1 @JustSym0) SJust)) SZero)))
+      = applySing
+          (applySing
+             (applySing (singFun3 @Tuple3Sym0 STuple3) SFalse)
+             (applySing (singFun1 @JustSym0 SJust) SZero))
           STrue
     sComplex
-      = (applySing
-           ((applySing ((singFun2 @PairSym0) SPair))
-              ((applySing
-                  ((applySing ((singFun2 @PairSym0) SPair))
-                     ((applySing ((singFun1 @JustSym0) SJust)) SZero)))
-                 SZero)))
+      = applySing
+          (applySing
+             (singFun2 @PairSym0 SPair)
+             (applySing
+                (applySing
+                   (singFun2 @PairSym0 SPair)
+                   (applySing (singFun1 @JustSym0 SJust) SZero))
+                SZero))
           SFalse
     sPr
-      = (applySing
-           ((applySing ((singFun2 @PairSym0) SPair))
-              ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero)) SNil)
+      = applySing
+          (applySing
+             (singFun2 @PairSym0 SPair)
+             (applySing (singFun1 @SuccSym0 SSucc) SZero))
+          (applySing (applySing (singFun2 @(:@#@$) SCons) SZero) SNil)
     data SPair :: forall a b. Pair a b -> Type
       where
         SPair :: forall a b (n :: a) (n :: b).
@@ -129,65 +105,62 @@
     type instance Sing @(Pair a b) = SPair
     instance (SingKind a, SingKind b) => SingKind (Pair a b) where
       type Demote (Pair a b) = Pair (Demote a) (Demote b)
-      fromSing (SPair b b) = (Pair (fromSing b)) (fromSing b)
+      fromSing (SPair b b) = Pair (fromSing b) (fromSing b)
       toSing (Pair (b :: Demote a) (b :: Demote b))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SPair c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SPair c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
     instance (SShow a, SShow b) => SShow (Pair a b) where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: Pair a b)
-               (t3 :: Symbol). Sing t1
-                               -> Sing t2
-                                  -> Sing t3
-                                     -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol))
-                                                                                    -> Type) t1) t2) t3)
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         (SPair (sArg_0123456789876543210 :: Sing arg_0123456789876543210)
                (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "Pair "))))
-                   ((applySing
-                       ((applySing ((singFun3 @(.@#@$)) (%.)))
-                          ((applySing
-                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                 (sFromInteger (sing :: Sing 11))))
-                             sArg_0123456789876543210)))
-                      ((applySing
-                          ((applySing ((singFun3 @(.@#@$)) (%.)))
-                             ((singFun1 @ShowSpaceSym0) sShowSpace)))
-                         ((applySing
-                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                (sFromInteger (sing :: Sing 11))))
-                            sArg_0123456789876543210))))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Pair ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @(.@#@$) (%.))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun3 @(.@#@$) (%.)) (singFun1 @ShowSpaceSym0 sShowSpace))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210)))))
             sA_0123456789876543210
     deriving instance (Data.Singletons.ShowSing.ShowSing a,
                        Data.Singletons.ShowSing.ShowSing b) =>
                       Show (SPair (z :: Pair a b))
     instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where
-      sing = (SPair sing) sing
+      sing = SPair sing sing
     instance SingI n => SingI1 (Pair (n :: a)) where
       liftSing = SPair sing
     instance SingI2 Pair where
       liftSing2 = SPair
     instance SingI (PairSym0 :: (~>) a ((~>) b (Pair a b))) where
-      sing = (singFun2 @PairSym0) SPair
+      sing = singFun2 @PairSym0 SPair
     instance SingI d =>
              SingI (PairSym1 (d :: a) :: (~>) b (Pair a b)) where
-      sing = (singFun1 @(PairSym1 (d :: a))) (SPair (sing @d))
+      sing = singFun1 @(PairSym1 (d :: a)) (SPair (sing @d))
     instance SingI1 (PairSym1 :: a -> (~>) b (Pair a b)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(PairSym1 (d :: a))) (SPair s)
+        = singFun1 @(PairSym1 (d :: a)) (SPair s)
 Singletons/PatternMatching.hs:(0,0)-(0,0): Splicing declarations
     singletons
       [d| Pair sz lz = pr
@@ -215,169 +188,225 @@
     foo2 t@(# x, y #) = case t of (# a, b #) -> (\ _ -> a) b
     silly :: a -> ()
     silly x = case x of _ -> ()
-    type family Case_0123456789876543210 x t where
-      Case_0123456789876543210 x _ = Tuple0Sym0
-    data Let0123456789876543210TSym0 x0123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 x _ = Tuple0Sym0
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210TSym0KindInference :: SameKind (Apply Let0123456789876543210TSym0 arg) (Let0123456789876543210TSym1 arg) =>
-                                                    Let0123456789876543210TSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210TSym0 x0123456789876543210 = Let0123456789876543210TSym1 x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210TSym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210TSym0KindInference) ())
-    data Let0123456789876543210TSym1 x0123456789876543210 y0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type family Let0123456789876543210TSym0 x0123456789876543210 y0123456789876543210 where
+      Let0123456789876543210TSym0 x0123456789876543210 y0123456789876543210 = Let0123456789876543210T x0123456789876543210 y0123456789876543210
+    type family Let0123456789876543210T x0123456789876543210 y0123456789876543210 where
+      Let0123456789876543210T x y = Apply (Apply Tuple2Sym0 x) y
+    type family LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 a b x y _ = a
+    data LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210TSym1KindInference :: SameKind (Apply (Let0123456789876543210TSym1 x0123456789876543210) arg) (Let0123456789876543210TSym2 x0123456789876543210 arg) =>
-                                                    Let0123456789876543210TSym1 x0123456789876543210 y0123456789876543210
-    type instance Apply (Let0123456789876543210TSym1 x0123456789876543210) y0123456789876543210 = Let0123456789876543210T x0123456789876543210 y0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210TSym1 x0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210TSym1KindInference) ())
-    type family Let0123456789876543210TSym2 x0123456789876543210 y0123456789876543210 where
-      Let0123456789876543210TSym2 x0123456789876543210 y0123456789876543210 = Let0123456789876543210T x0123456789876543210 y0123456789876543210
-    type family Let0123456789876543210T x y where
-      Let0123456789876543210T x y = Apply (Apply Tuple2Sym0 x) y
-    type family Case_0123456789876543210 arg_0123456789876543210 a b x y t where
-      Case_0123456789876543210 arg_0123456789876543210 a b x y _ = a
-    type family Lambda_0123456789876543210 a b x y arg_0123456789876543210 where
-      Lambda_0123456789876543210 a b x y arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 a b x y arg_0123456789876543210
-    data Lambda_0123456789876543210Sym0 a0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x y '(a,
+                                         b) = Apply (LamCases_0123456789876543210Sym0 a b x y) b
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 a0123456789876543210 = Lambda_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x y _ = x
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 a0123456789876543210) arg) (Lambda_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 a0123456789876543210) b0123456789876543210 = Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 '[_,
+                                     _,
+                                     'Succ y_0123456789876543210] = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 '[_,
+                                     y_0123456789876543210,
+                                     'Succ _] = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210) arg) (Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210) y0123456789876543210 = Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    data Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 '(_,
+                                     _,
+                                     y_0123456789876543210) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym4KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym5 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())
-    type family Lambda_0123456789876543210Sym5 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym5 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    type family Case_0123456789876543210 x y t where
-      Case_0123456789876543210 x y '(a,
-                                     b) = Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) x) y) b
-    type family Case_0123456789876543210 arg_0123456789876543210 x y t where
-      Case_0123456789876543210 arg_0123456789876543210 x y _ = x
-    type family Lambda_0123456789876543210 x y arg_0123456789876543210 where
-      Lambda_0123456789876543210 x y arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 '(_,
+                                     y_0123456789876543210,
+                                     _) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 '(y_0123456789876543210,
+                                     _,
+                                     _) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) y0123456789876543210 = Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 ('Pair ('Pair _ _) y_0123456789876543210) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 arg_01234567898765432100123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 '[_,
-                                 _,
-                                 'Succ y_0123456789876543210] = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 '[_,
-                                 y_0123456789876543210,
-                                 'Succ _] = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 '(_,
-                                 _,
-                                 y_0123456789876543210) = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 '(_,
-                                 y_0123456789876543210,
-                                 _) = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 '(y_0123456789876543210,
-                                 _,
-                                 _) = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 ('Pair ('Pair _ _) y_0123456789876543210) = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 ('Pair ('Pair _ y_0123456789876543210) _) = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 ('Pair ('Pair y_0123456789876543210 _) _) = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 ('Pair _ y_0123456789876543210) = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 ('Pair y_0123456789876543210 _) = y_0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 ('Pair ('Pair _ y_0123456789876543210) _) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 ('Pair ('Pair y_0123456789876543210 _) _) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 ('Pair _ y_0123456789876543210) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 ('Pair y_0123456789876543210 _) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
     type SillySym0 :: (~>) a ()
     data SillySym0 :: (~>) a ()
       where
         SillySym0KindInference :: SameKind (Apply SillySym0 arg) (SillySym1 arg) =>
                                   SillySym0 a0123456789876543210
-    type instance Apply SillySym0 a0123456789876543210 = Silly a0123456789876543210
+    type instance Apply @a @() SillySym0 a0123456789876543210 = Silly a0123456789876543210
     instance SuppressUnusedWarnings SillySym0 where
-      suppressUnusedWarnings = snd (((,) SillySym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SillySym0KindInference ())
     type SillySym1 :: a -> ()
-    type family SillySym1 (a0123456789876543210 :: a) :: () where
+    type family SillySym1 @a (a0123456789876543210 :: a) :: () where
       SillySym1 a0123456789876543210 = Silly a0123456789876543210
     type Foo2Sym0 :: (~>) (a, b) a
     data Foo2Sym0 :: (~>) (a, b) a
       where
         Foo2Sym0KindInference :: SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>
                                  Foo2Sym0 a0123456789876543210
-    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2 a0123456789876543210
+    type instance Apply @(a,
+                          b) @a Foo2Sym0 a0123456789876543210 = Foo2 a0123456789876543210
     instance SuppressUnusedWarnings Foo2Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo2Sym0KindInference ())
     type Foo2Sym1 :: (a, b) -> a
-    type family Foo2Sym1 (a0123456789876543210 :: (a, b)) :: a where
+    type family Foo2Sym1 @a @b (a0123456789876543210 :: (a,
+                                                         b)) :: a where
       Foo2Sym1 a0123456789876543210 = Foo2 a0123456789876543210
     type Foo1Sym0 :: (~>) (a, b) a
     data Foo1Sym0 :: (~>) (a, b) a
       where
         Foo1Sym0KindInference :: SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>
                                  Foo1Sym0 a0123456789876543210
-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210
+    type instance Apply @(a,
+                          b) @a Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210
     instance SuppressUnusedWarnings Foo1Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo1Sym0KindInference ())
     type Foo1Sym1 :: (a, b) -> a
-    type family Foo1Sym1 (a0123456789876543210 :: (a, b)) :: a where
+    type family Foo1Sym1 @a @b (a0123456789876543210 :: (a,
+                                                         b)) :: a where
       Foo1Sym1 a0123456789876543210 = Foo1 a0123456789876543210
     type family BlimySym0 where
       BlimySym0 = Blimy
@@ -410,168 +439,188 @@
     type family X_0123456789876543210Sym0 where
       X_0123456789876543210Sym0 = X_0123456789876543210
     type Silly :: a -> ()
-    type family Silly (a :: a) :: () where
-      Silly x = Case_0123456789876543210 x x
+    type family Silly @a (a :: a) :: () where
+      Silly x = Apply (LamCases_0123456789876543210Sym0 x) x
     type Foo2 :: (a, b) -> a
-    type family Foo2 (a :: (a, b)) :: a where
+    type family Foo2 @a @b (a :: (a, b)) :: a where
       Foo2 '(x,
-             y) = Case_0123456789876543210 x y (Let0123456789876543210TSym2 x y)
+             y) = Apply (LamCases_0123456789876543210Sym0 x y) (Let0123456789876543210TSym0 x y)
     type Foo1 :: (a, b) -> a
-    type family Foo1 (a :: (a, b)) :: a where
-      Foo1 '(x,
-             y) = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y
+    type family Foo1 @a @b (a :: (a, b)) :: a where
+      Foo1 '(x, y) = Apply (LamCases_0123456789876543210Sym0 x y) y
     type family Blimy where
-      Blimy = Case_0123456789876543210 X_0123456789876543210Sym0
+      Blimy = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type Lsz :: Nat
     type family Lsz :: Nat where
-      Lsz = Case_0123456789876543210 X_0123456789876543210Sym0
+      Lsz = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type family X_0123456789876543210 where
       X_0123456789876543210 = AListSym0
     type family Tt where
-      Tt = Case_0123456789876543210 X_0123456789876543210Sym0
+      Tt = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type family Tjz where
-      Tjz = Case_0123456789876543210 X_0123456789876543210Sym0
+      Tjz = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type family Tf where
-      Tf = Case_0123456789876543210 X_0123456789876543210Sym0
+      Tf = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type family X_0123456789876543210 where
       X_0123456789876543210 = TupleSym0
     type Fls :: Bool
     type family Fls :: Bool where
-      Fls = Case_0123456789876543210 X_0123456789876543210Sym0
+      Fls = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type family Zz where
-      Zz = Case_0123456789876543210 X_0123456789876543210Sym0
+      Zz = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type family Jz where
-      Jz = Case_0123456789876543210 X_0123456789876543210Sym0
+      Jz = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type family X_0123456789876543210 where
       X_0123456789876543210 = ComplexSym0
     type family Lz where
-      Lz = Case_0123456789876543210 X_0123456789876543210Sym0
+      Lz = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type family Sz where
-      Sz = Case_0123456789876543210 X_0123456789876543210Sym0
+      Sz = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type family X_0123456789876543210 where
       X_0123456789876543210 = PrSym0
-    sSilly ::
-      forall a (t :: a). Sing t -> Sing (Apply SillySym0 t :: ())
+    sSilly :: (forall (t :: a). Sing t -> Sing (Silly t :: ()) :: Type)
     sFoo2 ::
-      forall a b (t :: (a, b)). Sing t -> Sing (Apply Foo2Sym0 t :: a)
+      (forall (t :: (a, b)). Sing t -> Sing (Foo2 t :: a) :: Type)
     sFoo1 ::
-      forall a b (t :: (a, b)). Sing t -> Sing (Apply Foo1Sym0 t :: a)
-    sBlimy :: Sing @_ BlimySym0
-    sLsz :: Sing (LszSym0 :: Nat)
-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0
-    sTt :: Sing @_ TtSym0
-    sTjz :: Sing @_ TjzSym0
-    sTf :: Sing @_ TfSym0
-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0
-    sFls :: Sing (FlsSym0 :: Bool)
-    sZz :: Sing @_ ZzSym0
-    sJz :: Sing @_ JzSym0
-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0
-    sLz :: Sing @_ LzSym0
-    sSz :: Sing @_ SzSym0
-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0
+      (forall (t :: (a, b)). Sing t -> Sing (Foo1 t :: a) :: Type)
+    sBlimy :: Sing @_ Blimy
+    sLsz :: (Sing (Lsz :: Nat) :: Type)
+    sX_0123456789876543210 :: Sing @_ X_0123456789876543210
+    sTt :: Sing @_ Tt
+    sTjz :: Sing @_ Tjz
+    sTf :: Sing @_ Tf
+    sX_0123456789876543210 :: Sing @_ X_0123456789876543210
+    sFls :: (Sing (Fls :: Bool) :: Type)
+    sZz :: Sing @_ Zz
+    sJz :: Sing @_ Jz
+    sX_0123456789876543210 :: Sing @_ X_0123456789876543210
+    sLz :: Sing @_ Lz
+    sSz :: Sing @_ Sz
+    sX_0123456789876543210 :: Sing @_ X_0123456789876543210
     sSilly (sX :: Sing x)
-      = (id @(Sing (Case_0123456789876543210 x x :: ())))
-          (case sX of _ -> STuple0)
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 x) (\cases _ -> STuple0))
+          sX
     sFoo2 (STuple2 (sX :: Sing x) (sY :: Sing y))
       = let
-          sT :: Sing @_ (Let0123456789876543210TSym2 x y)
-          sT
-            = (applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX)) sY
+          sT :: Sing @_ (Let0123456789876543210T x y)
+          sT = applySing (applySing (singFun2 @Tuple2Sym0 STuple2) sX) sY
         in
-          (id
-             @(Sing (Case_0123456789876543210 x y (Let0123456789876543210TSym2 x y) :: a)))
-            (case sT of
-               STuple2 (sA :: Sing a) (sB :: Sing b)
-                 -> (applySing
-                       ((singFun1
-                           @(Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) x) y))
-                          (\ sArg_0123456789876543210
-                             -> case sArg_0123456789876543210 of
-                                  (_ :: Sing arg_0123456789876543210)
-                                    -> (id
-                                          @(Sing (Case_0123456789876543210 arg_0123456789876543210 a b x y arg_0123456789876543210)))
-                                         (case sArg_0123456789876543210 of _ -> sA))))
-                      sB)
+          applySing
+            (singFun1
+               @(LamCases_0123456789876543210Sym0 x y)
+               (\cases
+                  (STuple2 (sA :: Sing a) (sB :: Sing b))
+                    -> applySing
+                         (singFun1
+                            @(LamCases_0123456789876543210Sym0 a b x y) (\cases _ -> sA))
+                         sB))
+            sT
     sFoo1 (STuple2 (sX :: Sing x) (sY :: Sing y))
-      = (applySing
-           ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y))
-              (\ sArg_0123456789876543210
-                 -> case sArg_0123456789876543210 of
-                      (_ :: Sing arg_0123456789876543210)
-                        -> (id
-                              @(Sing (Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210)))
-                             (case sArg_0123456789876543210 of _ -> sX))))
+      = applySing
+          (singFun1 @(LamCases_0123456789876543210Sym0 x y) (\cases _ -> sX))
           sY
     sBlimy
-      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))
-          (case sX_0123456789876543210 of
-             SCons _
-                   (SCons _
-                          (SCons (SSucc (sY_0123456789876543210 :: Sing y_0123456789876543210))
-                                 SNil))
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (SCons _
+                       (SCons _
+                              (SCons (SSucc (sY_0123456789876543210 :: Sing y_0123456789876543210))
+                                     SNil)))
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sLsz
-      = (id
-           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Nat)))
-          (case sX_0123456789876543210 of
-             SCons _
-                   (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)
-                          (SCons (SSucc _) SNil))
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (SCons _
+                       (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)
+                              (SCons (SSucc _) SNil)))
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sX_0123456789876543210 = sAList
     sTt
-      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))
-          (case sX_0123456789876543210 of
-             STuple3 _ _ (sY_0123456789876543210 :: Sing y_0123456789876543210)
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (STuple3 _ _
+                         (sY_0123456789876543210 :: Sing y_0123456789876543210))
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sTjz
-      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))
-          (case sX_0123456789876543210 of
-             STuple3 _ (sY_0123456789876543210 :: Sing y_0123456789876543210) _
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (STuple3 _ (sY_0123456789876543210 :: Sing y_0123456789876543210)
+                         _)
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sTf
-      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))
-          (case sX_0123456789876543210 of
-             STuple3 (sY_0123456789876543210 :: Sing y_0123456789876543210) _ _
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (STuple3 (sY_0123456789876543210 :: Sing y_0123456789876543210) _
+                         _)
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sX_0123456789876543210 = sTuple
     sFls
-      = (id
-           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)))
-          (case sX_0123456789876543210 of
-             SPair (SPair _ _)
-                   (sY_0123456789876543210 :: Sing y_0123456789876543210)
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (SPair (SPair _ _)
+                       (sY_0123456789876543210 :: Sing y_0123456789876543210))
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sZz
-      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))
-          (case sX_0123456789876543210 of
-             SPair (SPair _
-                          (sY_0123456789876543210 :: Sing y_0123456789876543210))
-                   _
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (SPair (SPair _
+                              (sY_0123456789876543210 :: Sing y_0123456789876543210))
+                       _)
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sJz
-      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))
-          (case sX_0123456789876543210 of
-             SPair (SPair (sY_0123456789876543210 :: Sing y_0123456789876543210)
-                          _)
-                   _
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (SPair (SPair (sY_0123456789876543210 :: Sing y_0123456789876543210)
+                              _)
+                       _)
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sX_0123456789876543210 = sComplex
     sLz
-      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))
-          (case sX_0123456789876543210 of
-             SPair _ (sY_0123456789876543210 :: Sing y_0123456789876543210)
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (SPair _ (sY_0123456789876543210 :: Sing y_0123456789876543210))
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sSz
-      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))
-          (case sX_0123456789876543210 of
-             SPair (sY_0123456789876543210 :: Sing y_0123456789876543210) _
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (SPair (sY_0123456789876543210 :: Sing y_0123456789876543210) _)
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sX_0123456789876543210 = sPr
     instance SingI (SillySym0 :: (~>) a ()) where
-      sing = (singFun1 @SillySym0) sSilly
+      sing = singFun1 @SillySym0 sSilly
     instance SingI (Foo2Sym0 :: (~>) (a, b) a) where
-      sing = (singFun1 @Foo2Sym0) sFoo2
+      sing = singFun1 @Foo2Sym0 sFoo2
     instance SingI (Foo1Sym0 :: (~>) (a, b) a) where
-      sing = (singFun1 @Foo1Sym0) sFoo1
+      sing = singFun1 @Foo1Sym0 sFoo1
diff --git a/tests/compile-and-dump/Singletons/PolyKinds.golden b/tests/compile-and-dump/Singletons/PolyKinds.golden
--- a/tests/compile-and-dump/Singletons/PolyKinds.golden
+++ b/tests/compile-and-dump/Singletons/PolyKinds.golden
@@ -10,18 +10,18 @@
       where
         FffSym0KindInference :: SameKind (Apply FffSym0 arg) (FffSym1 arg) =>
                                 FffSym0 a0123456789876543210
-    type instance Apply FffSym0 a0123456789876543210 = Fff a0123456789876543210
+    type instance Apply @(Proxy (a :: k)) @() FffSym0 a0123456789876543210 = Fff a0123456789876543210
     instance SuppressUnusedWarnings FffSym0 where
-      suppressUnusedWarnings = snd (((,) FffSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FffSym0KindInference ())
     type FffSym1 :: forall k (a :: k). Proxy (a :: k) -> ()
-    type family FffSym1 (a0123456789876543210 :: Proxy (a :: k)) :: () where
+    type family FffSym1 @k @(a :: k) (a0123456789876543210 :: Proxy (a :: k)) :: () where
       FffSym1 a0123456789876543210 = Fff a0123456789876543210
     class PCls (a :: k) where
       type family Fff (arg :: Proxy (a :: k)) :: ()
     class SCls (a :: k) where
       sFff ::
-        forall (t :: Proxy (a :: k)). Sing t
-                                      -> Sing (Apply FffSym0 t :: ())
+        (forall (t :: Proxy (a :: k)).
+         Sing t -> Sing (Fff t :: ()) :: Type)
     instance SCls a =>
              SingI (FffSym0 :: (~>) (Proxy (a :: k)) ()) where
-      sing = (singFun1 @FffSym0) sFff
+      sing = singFun1 @FffSym0 sFff
diff --git a/tests/compile-and-dump/Singletons/PolyKindsApp.golden b/tests/compile-and-dump/Singletons/PolyKindsApp.golden
--- a/tests/compile-and-dump/Singletons/PolyKindsApp.golden
+++ b/tests/compile-and-dump/Singletons/PolyKindsApp.golden
@@ -7,10 +7,10 @@
       fff :: (a :: k -> Type) (b :: k)
     type FffSym0 :: forall k (a :: k -> Type) (b :: k). (a :: k
                                                               -> Type) (b :: k)
-    type family FffSym0 :: (a :: k -> Type) (b :: k) where
+    type family FffSym0 @k @(a :: k -> Type) @(b :: k) :: (a :: k
+                                                                -> Type) (b :: k) where
       FffSym0 = Fff
     class PCls (a :: k -> Type) where
       type family Fff :: (a :: k -> Type) (b :: k)
     class SCls (a :: k -> Type) where
-      sFff ::
-        forall (b :: k). Sing (FffSym0 :: (a :: k -> Type) (b :: k))
+      sFff :: (Sing (Fff :: (a :: k -> Type) (b :: k)) :: Type)
diff --git a/tests/compile-and-dump/Singletons/Records.golden b/tests/compile-and-dump/Singletons/Records.golden
--- a/tests/compile-and-dump/Singletons/Records.golden
+++ b/tests/compile-and-dump/Singletons/Records.golden
@@ -8,59 +8,57 @@
       where
         MkRecordSym0KindInference :: SameKind (Apply MkRecordSym0 arg) (MkRecordSym1 arg) =>
                                      MkRecordSym0 a0123456789876543210
-    type instance Apply MkRecordSym0 a0123456789876543210 = MkRecordSym1 a0123456789876543210
+    type instance Apply @a @((~>) Bool (Record a)) MkRecordSym0 a0123456789876543210 = MkRecordSym1 a0123456789876543210
     instance SuppressUnusedWarnings MkRecordSym0 where
-      suppressUnusedWarnings = snd (((,) MkRecordSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkRecordSym0KindInference ())
     type MkRecordSym1 :: forall a. a -> (~>) Bool (Record a)
     data MkRecordSym1 (a0123456789876543210 :: a) :: (~>) Bool (Record a)
       where
         MkRecordSym1KindInference :: SameKind (Apply (MkRecordSym1 a0123456789876543210) arg) (MkRecordSym2 a0123456789876543210 arg) =>
                                      MkRecordSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkRecordSym1 a0123456789876543210) a0123456789876543210 = MkRecord a0123456789876543210 a0123456789876543210
+    type instance Apply @Bool @(Record a) (MkRecordSym1 a0123456789876543210) a0123456789876543210 = MkRecord a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MkRecordSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkRecordSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkRecordSym1KindInference ())
     type MkRecordSym2 :: forall a. a -> Bool -> Record a
-    type family MkRecordSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: Bool) :: Record a where
+    type family MkRecordSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: Bool) :: Record a where
       MkRecordSym2 a0123456789876543210 a0123456789876543210 = MkRecord a0123456789876543210 a0123456789876543210
     type Field2Sym0 :: forall a. (~>) (Record a) Bool
     data Field2Sym0 :: (~>) (Record a) Bool
       where
         Field2Sym0KindInference :: SameKind (Apply Field2Sym0 arg) (Field2Sym1 arg) =>
                                    Field2Sym0 a0123456789876543210
-    type instance Apply Field2Sym0 a0123456789876543210 = Field2 a0123456789876543210
+    type instance Apply @(Record a) @Bool Field2Sym0 a0123456789876543210 = Field2 a0123456789876543210
     instance SuppressUnusedWarnings Field2Sym0 where
-      suppressUnusedWarnings = snd (((,) Field2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Field2Sym0KindInference ())
     type Field2Sym1 :: forall a. Record a -> Bool
-    type family Field2Sym1 (a0123456789876543210 :: Record a) :: Bool where
+    type family Field2Sym1 @a (a0123456789876543210 :: Record a) :: Bool where
       Field2Sym1 a0123456789876543210 = Field2 a0123456789876543210
     type Field1Sym0 :: forall a. (~>) (Record a) a
     data Field1Sym0 :: (~>) (Record a) a
       where
         Field1Sym0KindInference :: SameKind (Apply Field1Sym0 arg) (Field1Sym1 arg) =>
                                    Field1Sym0 a0123456789876543210
-    type instance Apply Field1Sym0 a0123456789876543210 = Field1 a0123456789876543210
+    type instance Apply @(Record a) @a Field1Sym0 a0123456789876543210 = Field1 a0123456789876543210
     instance SuppressUnusedWarnings Field1Sym0 where
-      suppressUnusedWarnings = snd (((,) Field1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Field1Sym0KindInference ())
     type Field1Sym1 :: forall a. Record a -> a
-    type family Field1Sym1 (a0123456789876543210 :: Record a) :: a where
+    type family Field1Sym1 @a (a0123456789876543210 :: Record a) :: a where
       Field1Sym1 a0123456789876543210 = Field1 a0123456789876543210
     type Field2 :: forall a. Record a -> Bool
-    type family Field2 (a :: Record a) :: Bool where
-      Field2 (MkRecord _ field) = field
+    type family Field2 @a (a :: Record a) :: Bool where
+      Field2 @a (MkRecord _ field :: Record a) = field
     type Field1 :: forall a. Record a -> a
-    type family Field1 (a :: Record a) :: a where
-      Field1 (MkRecord field _) = field
+    type family Field1 @a (a :: Record a) :: a where
+      Field1 @a (MkRecord field _ :: Record a) = field
     sField2 ::
-      forall a (t :: Record a). Sing t
-                                -> Sing (Apply Field2Sym0 t :: Bool)
-    sField1 ::
-      forall a (t :: Record a). Sing t -> Sing (Apply Field1Sym0 t :: a)
+      forall a (t :: Record a). Sing t -> Sing (Field2 t :: Bool)
+    sField1 :: forall a (t :: Record a). Sing t -> Sing (Field1 t :: a)
     sField2 (SMkRecord _ (sField :: Sing field)) = sField
     sField1 (SMkRecord (sField :: Sing field) _) = sField
     instance SingI (Field2Sym0 :: (~>) (Record a) Bool) where
-      sing = (singFun1 @Field2Sym0) sField2
+      sing = singFun1 @Field2Sym0 sField2
     instance SingI (Field1Sym0 :: (~>) (Record a) a) where
-      sing = (singFun1 @Field1Sym0) sField1
+      sing = singFun1 @Field1Sym0 sField1
     data SRecord :: forall a. Record a -> Type
       where
         SMkRecord :: forall a (n :: a) (n :: Bool).
@@ -68,24 +66,22 @@
     type instance Sing @(Record a) = SRecord
     instance SingKind a => SingKind (Record a) where
       type Demote (Record a) = Record (Demote a)
-      fromSing (SMkRecord b b) = (MkRecord (fromSing b)) (fromSing b)
+      fromSing (SMkRecord b b) = MkRecord (fromSing b) (fromSing b)
       toSing (MkRecord (b :: Demote a) (b :: Demote Bool))
-        = case
-              ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing Bool)
-          of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkRecord c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SMkRecord c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing Bool)
     instance (SingI n, SingI n) =>
              SingI (MkRecord (n :: a) (n :: Bool)) where
-      sing = (SMkRecord sing) sing
+      sing = SMkRecord sing sing
     instance SingI n => SingI1 (MkRecord (n :: a)) where
       liftSing = SMkRecord sing
     instance SingI2 MkRecord where
       liftSing2 = SMkRecord
     instance SingI (MkRecordSym0 :: (~>) a ((~>) Bool (Record a))) where
-      sing = (singFun2 @MkRecordSym0) SMkRecord
+      sing = singFun2 @MkRecordSym0 SMkRecord
     instance SingI d =>
              SingI (MkRecordSym1 (d :: a) :: (~>) Bool (Record a)) where
-      sing = (singFun1 @(MkRecordSym1 (d :: a))) (SMkRecord (sing @d))
+      sing = singFun1 @(MkRecordSym1 (d :: a)) (SMkRecord (sing @d))
     instance SingI1 (MkRecordSym1 :: a -> (~>) Bool (Record a)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(MkRecordSym1 (d :: a))) (SMkRecord s)
+        = singFun1 @(MkRecordSym1 (d :: a)) (SMkRecord s)
diff --git a/tests/compile-and-dump/Singletons/ReturnFunc.golden b/tests/compile-and-dump/Singletons/ReturnFunc.golden
--- a/tests/compile-and-dump/Singletons/ReturnFunc.golden
+++ b/tests/compile-and-dump/Singletons/ReturnFunc.golden
@@ -18,88 +18,88 @@
       where
         IdFooSym0KindInference :: SameKind (Apply IdFooSym0 arg) (IdFooSym1 arg) =>
                                   IdFooSym0 a0123456789876543210
-    type instance Apply IdFooSym0 a0123456789876543210 = IdFooSym1 a0123456789876543210
+    type instance Apply @c @((~>) a a) IdFooSym0 a0123456789876543210 = IdFooSym1 a0123456789876543210
     instance SuppressUnusedWarnings IdFooSym0 where
-      suppressUnusedWarnings = snd (((,) IdFooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) IdFooSym0KindInference ())
     type IdFooSym1 :: c -> (~>) a a
     data IdFooSym1 (a0123456789876543210 :: c) :: (~>) a a
       where
         IdFooSym1KindInference :: SameKind (Apply (IdFooSym1 a0123456789876543210) arg) (IdFooSym2 a0123456789876543210 arg) =>
                                   IdFooSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (IdFooSym1 a0123456789876543210) a0123456789876543210 = IdFoo a0123456789876543210 a0123456789876543210
+    type instance Apply @a @a (IdFooSym1 a0123456789876543210) a0123456789876543210 = IdFoo a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (IdFooSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) IdFooSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) IdFooSym1KindInference ())
     type IdFooSym2 :: c -> a -> a
-    type family IdFooSym2 (a0123456789876543210 :: c) (a0123456789876543210 :: a) :: a where
+    type family IdFooSym2 @c @a (a0123456789876543210 :: c) (a0123456789876543210 :: a) :: a where
       IdFooSym2 a0123456789876543210 a0123456789876543210 = IdFoo a0123456789876543210 a0123456789876543210
     type IdSym0 :: (~>) a a
     data IdSym0 :: (~>) a a
       where
         IdSym0KindInference :: SameKind (Apply IdSym0 arg) (IdSym1 arg) =>
                                IdSym0 a0123456789876543210
-    type instance Apply IdSym0 a0123456789876543210 = Id a0123456789876543210
+    type instance Apply @a @a IdSym0 a0123456789876543210 = Id a0123456789876543210
     instance SuppressUnusedWarnings IdSym0 where
-      suppressUnusedWarnings = snd (((,) IdSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) IdSym0KindInference ())
     type IdSym1 :: a -> a
-    type family IdSym1 (a0123456789876543210 :: a) :: a where
+    type family IdSym1 @a (a0123456789876543210 :: a) :: a where
       IdSym1 a0123456789876543210 = Id a0123456789876543210
     type ReturnFuncSym0 :: (~>) Nat ((~>) Nat Nat)
     data ReturnFuncSym0 :: (~>) Nat ((~>) Nat Nat)
       where
         ReturnFuncSym0KindInference :: SameKind (Apply ReturnFuncSym0 arg) (ReturnFuncSym1 arg) =>
                                        ReturnFuncSym0 a0123456789876543210
-    type instance Apply ReturnFuncSym0 a0123456789876543210 = ReturnFuncSym1 a0123456789876543210
+    type instance Apply @Nat @((~>) Nat Nat) ReturnFuncSym0 a0123456789876543210 = ReturnFuncSym1 a0123456789876543210
     instance SuppressUnusedWarnings ReturnFuncSym0 where
-      suppressUnusedWarnings = snd (((,) ReturnFuncSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) ReturnFuncSym0KindInference ())
     type ReturnFuncSym1 :: Nat -> (~>) Nat Nat
     data ReturnFuncSym1 (a0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
         ReturnFuncSym1KindInference :: SameKind (Apply (ReturnFuncSym1 a0123456789876543210) arg) (ReturnFuncSym2 a0123456789876543210 arg) =>
                                        ReturnFuncSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ReturnFuncSym1 a0123456789876543210) a0123456789876543210 = ReturnFunc a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat (ReturnFuncSym1 a0123456789876543210) a0123456789876543210 = ReturnFunc a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (ReturnFuncSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ReturnFuncSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) ReturnFuncSym1KindInference ())
     type ReturnFuncSym2 :: Nat -> Nat -> Nat
     type family ReturnFuncSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
       ReturnFuncSym2 a0123456789876543210 a0123456789876543210 = ReturnFunc a0123456789876543210 a0123456789876543210
     type IdFoo :: c -> a -> a
-    type family IdFoo (a :: c) (a :: a) :: a where
+    type family IdFoo @c @a (a :: c) (a :: a) :: a where
       IdFoo _ a_0123456789876543210 = Apply IdSym0 a_0123456789876543210
     type Id :: a -> a
-    type family Id (a :: a) :: a where
+    type family Id @a (a :: a) :: a where
       Id x = x
     type ReturnFunc :: Nat -> Nat -> Nat
     type family ReturnFunc (a :: Nat) (a :: Nat) :: Nat where
       ReturnFunc _ a_0123456789876543210 = Apply SuccSym0 a_0123456789876543210
     sIdFoo ::
-      forall c a (t :: c) (t :: a). Sing t
-                                    -> Sing t -> Sing (Apply (Apply IdFooSym0 t) t :: a)
-    sId :: forall a (t :: a). Sing t -> Sing (Apply IdSym0 t :: a)
+      (forall (t :: c) (t :: a).
+       Sing t -> Sing t -> Sing (IdFoo t t :: a) :: Type)
+    sId :: (forall (t :: a). Sing t -> Sing (Id t :: a) :: Type)
     sReturnFunc ::
-      forall (t :: Nat) (t :: Nat). Sing t
-                                    -> Sing t -> Sing (Apply (Apply ReturnFuncSym0 t) t :: Nat)
+      (forall (t :: Nat) (t :: Nat).
+       Sing t -> Sing t -> Sing (ReturnFunc t t :: Nat) :: Type)
     sIdFoo _ (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing ((singFun1 @IdSym0) sId)) sA_0123456789876543210
+      = applySing (singFun1 @IdSym0 sId) sA_0123456789876543210
     sId (sX :: Sing x) = sX
     sReturnFunc
       _
       (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing ((singFun1 @SuccSym0) SSucc)) sA_0123456789876543210
+      = applySing (singFun1 @SuccSym0 SSucc) sA_0123456789876543210
     instance SingI (IdFooSym0 :: (~>) c ((~>) a a)) where
-      sing = (singFun2 @IdFooSym0) sIdFoo
+      sing = singFun2 @IdFooSym0 sIdFoo
     instance SingI d => SingI (IdFooSym1 (d :: c) :: (~>) a a) where
-      sing = (singFun1 @(IdFooSym1 (d :: c))) (sIdFoo (sing @d))
+      sing = singFun1 @(IdFooSym1 (d :: c)) (sIdFoo (sing @d))
     instance SingI1 (IdFooSym1 :: c -> (~>) a a) where
       liftSing (s :: Sing (d :: c))
-        = (singFun1 @(IdFooSym1 (d :: c))) (sIdFoo s)
+        = singFun1 @(IdFooSym1 (d :: c)) (sIdFoo s)
     instance SingI (IdSym0 :: (~>) a a) where
-      sing = (singFun1 @IdSym0) sId
+      sing = singFun1 @IdSym0 sId
     instance SingI (ReturnFuncSym0 :: (~>) Nat ((~>) Nat Nat)) where
-      sing = (singFun2 @ReturnFuncSym0) sReturnFunc
+      sing = singFun2 @ReturnFuncSym0 sReturnFunc
     instance SingI d =>
              SingI (ReturnFuncSym1 (d :: Nat) :: (~>) Nat Nat) where
       sing
-        = (singFun1 @(ReturnFuncSym1 (d :: Nat))) (sReturnFunc (sing @d))
+        = singFun1 @(ReturnFuncSym1 (d :: Nat)) (sReturnFunc (sing @d))
     instance SingI1 (ReturnFuncSym1 :: Nat -> (~>) Nat Nat) where
       liftSing (s :: Sing (d :: Nat))
-        = (singFun1 @(ReturnFuncSym1 (d :: Nat))) (sReturnFunc s)
+        = singFun1 @(ReturnFuncSym1 (d :: Nat)) (sReturnFunc s)
diff --git a/tests/compile-and-dump/Singletons/Sections.golden b/tests/compile-and-dump/Singletons/Sections.golden
--- a/tests/compile-and-dump/Singletons/Sections.golden
+++ b/tests/compile-and-dump/Singletons/Sections.golden
@@ -14,23 +14,23 @@
     (+) Zero m = m
     (+) (Succ n) m = Succ (n + m)
     foo1 :: [Nat]
-    foo1 = (map (Succ Zero +)) [Zero, Succ Zero]
+    foo1 = map (Succ Zero +) [Zero, Succ Zero]
     foo2 :: [Nat]
-    foo2 = (map (+ Succ Zero)) [Zero, Succ Zero]
+    foo2 = map (+ Succ Zero) [Zero, Succ Zero]
     foo3 :: [Nat]
-    foo3 = ((zipWith (+)) [Succ Zero, Succ Zero]) [Zero, Succ Zero]
-    type family Lambda_0123456789876543210 lhs_0123456789876543210 where
-      Lambda_0123456789876543210 lhs_0123456789876543210 = Apply (Apply (+@#@$) lhs_0123456789876543210) (Apply SuccSym0 ZeroSym0)
-    data Lambda_0123456789876543210Sym0 lhs_01234567898765432100123456789876543210
+    foo3 = zipWith (+) [Succ Zero, Succ Zero] [Zero, Succ Zero]
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 lhs_0123456789876543210 = Apply (Apply (+@#@$) lhs_0123456789876543210) (Apply SuccSym0 ZeroSym0)
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 lhs_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 lhs_01234567898765432100123456789876543210 = Lambda_0123456789876543210 lhs_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    type family Lambda_0123456789876543210Sym1 lhs_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym1 lhs_01234567898765432100123456789876543210 = Lambda_0123456789876543210 lhs_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
     type Foo3Sym0 :: [Nat]
     type family Foo3Sym0 :: [Nat] where
       Foo3Sym0 = Foo3
@@ -45,17 +45,17 @@
       where
         (:+@#@$###) :: SameKind (Apply (+@#@$) arg) ((+@#@$$) arg) =>
                        (+@#@$) a0123456789876543210
-    type instance Apply (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210
+    type instance Apply @Nat @((~>) Nat Nat) (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (+@#@$) where
-      suppressUnusedWarnings = snd (((,) (:+@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (:+@#@$###) ())
     type (+@#@$$) :: Nat -> (~>) Nat Nat
     data (+@#@$$) (a0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
         (:+@#@$$###) :: SameKind (Apply ((+@#@$$) a0123456789876543210) arg) ((+@#@$$$) a0123456789876543210 arg) =>
                         (+@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((+@#@$$) a0123456789876543210) a0123456789876543210 = (+) a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat ((+@#@$$) a0123456789876543210) a0123456789876543210 = (+) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((+@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:+@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (:+@#@$$###) ())
     type (+@#@$$$) :: Nat -> Nat -> Nat
     type family (+@#@$$$) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
       (+@#@$$$) a0123456789876543210 a0123456789876543210 = (+) a0123456789876543210 a0123456789876543210
@@ -64,7 +64,7 @@
       Foo3 = Apply (Apply (Apply ZipWithSym0 (+@#@$)) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) NilSym0))) (Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) NilSym0))
     type Foo2 :: [Nat]
     type family Foo2 :: [Nat] where
-      Foo2 = Apply (Apply MapSym0 Lambda_0123456789876543210Sym0) (Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) NilSym0))
+      Foo2 = Apply (Apply MapSym0 LamCases_0123456789876543210Sym0) (Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) NilSym0))
     type Foo1 :: [Nat]
     type family Foo1 :: [Nat] where
       Foo1 = Apply (Apply MapSym0 (Apply (+@#@$) (Apply SuccSym0 ZeroSym0))) (Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) NilSym0))
@@ -72,63 +72,75 @@
     type family (+) (a :: Nat) (a :: Nat) :: Nat where
       (+) 'Zero m = m
       (+) ('Succ n) m = Apply SuccSym0 (Apply (Apply (+@#@$) n) m)
-    sFoo3 :: Sing (Foo3Sym0 :: [Nat])
-    sFoo2 :: Sing (Foo2Sym0 :: [Nat])
-    sFoo1 :: Sing (Foo1Sym0 :: [Nat])
+    sFoo3 :: (Sing (Foo3 :: [Nat]) :: Type)
+    sFoo2 :: (Sing (Foo2 :: [Nat]) :: Type)
+    sFoo1 :: (Sing (Foo1 :: [Nat]) :: Type)
     (%+) ::
-      forall (t :: Nat) (t :: Nat). Sing t
-                                    -> Sing t -> Sing (Apply (Apply (+@#@$) t) t :: Nat)
+      (forall (t :: Nat) (t :: Nat).
+       Sing t -> Sing t -> Sing ((+) t t :: Nat) :: Type)
     sFoo3
-      = (applySing
-           ((applySing
-               ((applySing ((singFun3 @ZipWithSym0) sZipWith))
-                  ((singFun2 @(+@#@$)) (%+))))
-              ((applySing
-                  ((applySing ((singFun2 @(:@#@$)) SCons))
-                     ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
-                 ((applySing
-                     ((applySing ((singFun2 @(:@#@$)) SCons))
-                        ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
-                    SNil))))
-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))
-             ((applySing
-                 ((applySing ((singFun2 @(:@#@$)) SCons))
-                    ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
+      = applySing
+          (applySing
+             (applySing
+                (singFun3 @ZipWithSym0 sZipWith) (singFun2 @(+@#@$) (%+)))
+             (applySing
+                (applySing
+                   (singFun2 @(:@#@$) SCons)
+                   (applySing (singFun1 @SuccSym0 SSucc) SZero))
+                (applySing
+                   (applySing
+                      (singFun2 @(:@#@$) SCons)
+                      (applySing (singFun1 @SuccSym0 SSucc) SZero))
+                   SNil)))
+          (applySing
+             (applySing (singFun2 @(:@#@$) SCons) SZero)
+             (applySing
+                (applySing
+                   (singFun2 @(:@#@$) SCons)
+                   (applySing (singFun1 @SuccSym0 SSucc) SZero))
                 SNil))
     sFoo2
-      = (applySing
-           ((applySing ((singFun2 @MapSym0) sMap))
-              ((singFun1 @Lambda_0123456789876543210Sym0)
-                 (\ sLhs_0123456789876543210
-                    -> case sLhs_0123456789876543210 of
-                         (_ :: Sing lhs_0123456789876543210)
-                           -> (applySing
-                                 ((applySing ((singFun2 @(+@#@$)) (%+))) sLhs_0123456789876543210))
-                                ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))))
-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))
-             ((applySing
-                 ((applySing ((singFun2 @(:@#@$)) SCons))
-                    ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
+      = applySing
+          (applySing
+             (singFun2 @MapSym0 sMap)
+             (singFun1
+                @LamCases_0123456789876543210Sym0
+                (\cases
+                   (sLhs_0123456789876543210 :: Sing lhs_0123456789876543210)
+                     -> applySing
+                          (applySing (singFun2 @(+@#@$) (%+)) sLhs_0123456789876543210)
+                          (applySing (singFun1 @SuccSym0 SSucc) SZero))))
+          (applySing
+             (applySing (singFun2 @(:@#@$) SCons) SZero)
+             (applySing
+                (applySing
+                   (singFun2 @(:@#@$) SCons)
+                   (applySing (singFun1 @SuccSym0 SSucc) SZero))
                 SNil))
     sFoo1
-      = (applySing
-           ((applySing ((singFun2 @MapSym0) sMap))
-              ((applySing ((singFun2 @(+@#@$)) (%+)))
-                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))
-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))
-             ((applySing
-                 ((applySing ((singFun2 @(:@#@$)) SCons))
-                    ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))
+      = applySing
+          (applySing
+             (singFun2 @MapSym0 sMap)
+             (applySing
+                (singFun2 @(+@#@$) (%+))
+                (applySing (singFun1 @SuccSym0 SSucc) SZero)))
+          (applySing
+             (applySing (singFun2 @(:@#@$) SCons) SZero)
+             (applySing
+                (applySing
+                   (singFun2 @(:@#@$) SCons)
+                   (applySing (singFun1 @SuccSym0 SSucc) SZero))
                 SNil))
     (%+) SZero (sM :: Sing m) = sM
     (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)
-      = (applySing ((singFun1 @SuccSym0) SSucc))
-          ((applySing ((applySing ((singFun2 @(+@#@$)) (%+))) sN)) sM)
+      = applySing
+          (singFun1 @SuccSym0 SSucc)
+          (applySing (applySing (singFun2 @(+@#@$) (%+)) sN) sM)
     instance SingI ((+@#@$) :: (~>) Nat ((~>) Nat Nat)) where
-      sing = (singFun2 @(+@#@$)) (%+)
+      sing = singFun2 @(+@#@$) (%+)
     instance SingI d =>
              SingI ((+@#@$$) (d :: Nat) :: (~>) Nat Nat) where
-      sing = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) (sing @d))
+      sing = singFun1 @((+@#@$$) (d :: Nat)) ((%+) (sing @d))
     instance SingI1 ((+@#@$$) :: Nat -> (~>) Nat Nat) where
       liftSing (s :: Sing (d :: Nat))
-        = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) s)
+        = singFun1 @((+@#@$$) (d :: Nat)) ((%+) s)
diff --git a/tests/compile-and-dump/Singletons/ShowDeriving.golden b/tests/compile-and-dump/Singletons/ShowDeriving.golden
--- a/tests/compile-and-dump/Singletons/ShowDeriving.golden
+++ b/tests/compile-and-dump/Singletons/ShowDeriving.golden
@@ -32,102 +32,102 @@
       where
         MkFoo2aSym0KindInference :: SameKind (Apply MkFoo2aSym0 arg) (MkFoo2aSym1 arg) =>
                                     MkFoo2aSym0 a0123456789876543210
-    type instance Apply MkFoo2aSym0 a0123456789876543210 = MkFoo2aSym1 a0123456789876543210
+    type instance Apply @a @((~>) a (Foo2 a)) MkFoo2aSym0 a0123456789876543210 = MkFoo2aSym1 a0123456789876543210
     instance SuppressUnusedWarnings MkFoo2aSym0 where
-      suppressUnusedWarnings = snd (((,) MkFoo2aSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkFoo2aSym0KindInference ())
     type MkFoo2aSym1 :: forall a. a -> (~>) a (Foo2 a)
     data MkFoo2aSym1 (a0123456789876543210 :: a) :: (~>) a (Foo2 a)
       where
         MkFoo2aSym1KindInference :: SameKind (Apply (MkFoo2aSym1 a0123456789876543210) arg) (MkFoo2aSym2 a0123456789876543210 arg) =>
                                     MkFoo2aSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkFoo2aSym1 a0123456789876543210) a0123456789876543210 = MkFoo2a a0123456789876543210 a0123456789876543210
+    type instance Apply @a @(Foo2 a) (MkFoo2aSym1 a0123456789876543210) a0123456789876543210 = MkFoo2a a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MkFoo2aSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkFoo2aSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkFoo2aSym1KindInference ())
     type MkFoo2aSym2 :: forall a. a -> a -> Foo2 a
-    type family MkFoo2aSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Foo2 a where
+    type family MkFoo2aSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Foo2 a where
       MkFoo2aSym2 a0123456789876543210 a0123456789876543210 = MkFoo2a a0123456789876543210 a0123456789876543210
     type MkFoo2bSym0 :: forall a. (~>) a ((~>) a (Foo2 a))
     data MkFoo2bSym0 :: (~>) a ((~>) a (Foo2 a))
       where
         MkFoo2bSym0KindInference :: SameKind (Apply MkFoo2bSym0 arg) (MkFoo2bSym1 arg) =>
                                     MkFoo2bSym0 a0123456789876543210
-    type instance Apply MkFoo2bSym0 a0123456789876543210 = MkFoo2bSym1 a0123456789876543210
+    type instance Apply @a @((~>) a (Foo2 a)) MkFoo2bSym0 a0123456789876543210 = MkFoo2bSym1 a0123456789876543210
     instance SuppressUnusedWarnings MkFoo2bSym0 where
-      suppressUnusedWarnings = snd (((,) MkFoo2bSym0KindInference) ())
-    infixl 5 `MkFoo2bSym0`
+      suppressUnusedWarnings = snd ((,) MkFoo2bSym0KindInference ())
+    infixl 5 type `MkFoo2bSym0`
     type MkFoo2bSym1 :: forall a. a -> (~>) a (Foo2 a)
     data MkFoo2bSym1 (a0123456789876543210 :: a) :: (~>) a (Foo2 a)
       where
         MkFoo2bSym1KindInference :: SameKind (Apply (MkFoo2bSym1 a0123456789876543210) arg) (MkFoo2bSym2 a0123456789876543210 arg) =>
                                     MkFoo2bSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkFoo2bSym1 a0123456789876543210) a0123456789876543210 = MkFoo2b a0123456789876543210 a0123456789876543210
+    type instance Apply @a @(Foo2 a) (MkFoo2bSym1 a0123456789876543210) a0123456789876543210 = MkFoo2b a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MkFoo2bSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkFoo2bSym1KindInference) ())
-    infixl 5 `MkFoo2bSym1`
+      suppressUnusedWarnings = snd ((,) MkFoo2bSym1KindInference ())
+    infixl 5 type `MkFoo2bSym1`
     type MkFoo2bSym2 :: forall a. a -> a -> Foo2 a
-    type family MkFoo2bSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Foo2 a where
+    type family MkFoo2bSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Foo2 a where
       MkFoo2bSym2 a0123456789876543210 a0123456789876543210 = MkFoo2b a0123456789876543210 a0123456789876543210
-    infixl 5 `MkFoo2bSym2`
+    infixl 5 type `MkFoo2bSym2`
     type (:*:@#@$) :: forall a. (~>) a ((~>) a (Foo2 a))
     data (:*:@#@$) :: (~>) a ((~>) a (Foo2 a))
       where
         (::*:@#@$###) :: SameKind (Apply (:*:@#@$) arg) ((:*:@#@$$) arg) =>
                          (:*:@#@$) a0123456789876543210
-    type instance Apply (:*:@#@$) a0123456789876543210 = (:*:@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) a (Foo2 a)) (:*:@#@$) a0123456789876543210 = (:*:@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:*:@#@$) where
-      suppressUnusedWarnings = snd (((,) (::*:@#@$###)) ())
-    infixl 5 :*:@#@$
+      suppressUnusedWarnings = snd ((,) (::*:@#@$###) ())
+    infixl 5 type :*:@#@$
     type (:*:@#@$$) :: forall a. a -> (~>) a (Foo2 a)
     data (:*:@#@$$) (a0123456789876543210 :: a) :: (~>) a (Foo2 a)
       where
         (::*:@#@$$###) :: SameKind (Apply ((:*:@#@$$) a0123456789876543210) arg) ((:*:@#@$$$) a0123456789876543210 arg) =>
                           (:*:@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:*:@#@$$) a0123456789876543210) a0123456789876543210 = (:*:) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @(Foo2 a) ((:*:@#@$$) a0123456789876543210) a0123456789876543210 = (:*:) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:*:@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::*:@#@$$###)) ())
-    infixl 5 :*:@#@$$
+      suppressUnusedWarnings = snd ((,) (::*:@#@$$###) ())
+    infixl 5 type :*:@#@$$
     type (:*:@#@$$$) :: forall a. a -> a -> Foo2 a
-    type family (:*:@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Foo2 a where
+    type family (:*:@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Foo2 a where
       (:*:@#@$$$) a0123456789876543210 a0123456789876543210 = (:*:) a0123456789876543210 a0123456789876543210
-    infixl 5 :*:@#@$$$
+    infixl 5 type :*:@#@$$$
     type (:&:@#@$) :: forall a. (~>) a ((~>) a (Foo2 a))
     data (:&:@#@$) :: (~>) a ((~>) a (Foo2 a))
       where
         (::&:@#@$###) :: SameKind (Apply (:&:@#@$) arg) ((:&:@#@$$) arg) =>
                          (:&:@#@$) a0123456789876543210
-    type instance Apply (:&:@#@$) a0123456789876543210 = (:&:@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) a (Foo2 a)) (:&:@#@$) a0123456789876543210 = (:&:@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:&:@#@$) where
-      suppressUnusedWarnings = snd (((,) (::&:@#@$###)) ())
-    infixl 5 :&:@#@$
+      suppressUnusedWarnings = snd ((,) (::&:@#@$###) ())
+    infixl 5 type :&:@#@$
     type (:&:@#@$$) :: forall a. a -> (~>) a (Foo2 a)
     data (:&:@#@$$) (a0123456789876543210 :: a) :: (~>) a (Foo2 a)
       where
         (::&:@#@$$###) :: SameKind (Apply ((:&:@#@$$) a0123456789876543210) arg) ((:&:@#@$$$) a0123456789876543210 arg) =>
                           (:&:@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:&:@#@$$) a0123456789876543210) a0123456789876543210 = (:&:) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @(Foo2 a) ((:&:@#@$$) a0123456789876543210) a0123456789876543210 = (:&:) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:&:@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::&:@#@$$###)) ())
-    infixl 5 :&:@#@$$
+      suppressUnusedWarnings = snd ((,) (::&:@#@$$###) ())
+    infixl 5 type :&:@#@$$
     type (:&:@#@$$$) :: forall a. a -> a -> Foo2 a
-    type family (:&:@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Foo2 a where
+    type family (:&:@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Foo2 a where
       (:&:@#@$$$) a0123456789876543210 a0123456789876543210 = (:&:) a0123456789876543210 a0123456789876543210
-    infixl 5 :&:@#@$$$
+    infixl 5 type :&:@#@$$$
     type MkFoo3Sym0 :: (~>) Bool ((~>) Bool Foo3)
     data MkFoo3Sym0 :: (~>) Bool ((~>) Bool Foo3)
       where
         MkFoo3Sym0KindInference :: SameKind (Apply MkFoo3Sym0 arg) (MkFoo3Sym1 arg) =>
                                    MkFoo3Sym0 a0123456789876543210
-    type instance Apply MkFoo3Sym0 a0123456789876543210 = MkFoo3Sym1 a0123456789876543210
+    type instance Apply @Bool @((~>) Bool Foo3) MkFoo3Sym0 a0123456789876543210 = MkFoo3Sym1 a0123456789876543210
     instance SuppressUnusedWarnings MkFoo3Sym0 where
-      suppressUnusedWarnings = snd (((,) MkFoo3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkFoo3Sym0KindInference ())
     type MkFoo3Sym1 :: Bool -> (~>) Bool Foo3
     data MkFoo3Sym1 (a0123456789876543210 :: Bool) :: (~>) Bool Foo3
       where
         MkFoo3Sym1KindInference :: SameKind (Apply (MkFoo3Sym1 a0123456789876543210) arg) (MkFoo3Sym2 a0123456789876543210 arg) =>
                                    MkFoo3Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkFoo3Sym1 a0123456789876543210) a0123456789876543210 = MkFoo3 a0123456789876543210 a0123456789876543210
+    type instance Apply @Bool @Foo3 (MkFoo3Sym1 a0123456789876543210) a0123456789876543210 = MkFoo3 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MkFoo3Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkFoo3Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkFoo3Sym1KindInference ())
     type MkFoo3Sym2 :: Bool -> Bool -> Foo3
     type family MkFoo3Sym2 (a0123456789876543210 :: Bool) (a0123456789876543210 :: Bool) :: Foo3 where
       MkFoo3Sym2 a0123456789876543210 a0123456789876543210 = MkFoo3 a0123456789876543210 a0123456789876543210
@@ -136,9 +136,9 @@
       where
         (:***@#@$###) :: SameKind (Apply (***@#@$) arg) ((***@#@$$) arg) =>
                          (***@#@$) a0123456789876543210
-    type instance Apply (***@#@$) a0123456789876543210 = (***) a0123456789876543210
+    type instance Apply @Foo3 @Bool (***@#@$) a0123456789876543210 = (***) a0123456789876543210
     instance SuppressUnusedWarnings (***@#@$) where
-      suppressUnusedWarnings = snd (((,) (:***@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (:***@#@$###) ())
     type (***@#@$$) :: Foo3 -> Bool
     type family (***@#@$$) (a0123456789876543210 :: Foo3) :: Bool where
       (***@#@$$) a0123456789876543210 = (***) a0123456789876543210
@@ -147,9 +147,9 @@
       where
         GetFoo3aSym0KindInference :: SameKind (Apply GetFoo3aSym0 arg) (GetFoo3aSym1 arg) =>
                                      GetFoo3aSym0 a0123456789876543210
-    type instance Apply GetFoo3aSym0 a0123456789876543210 = GetFoo3a a0123456789876543210
+    type instance Apply @Foo3 @Bool GetFoo3aSym0 a0123456789876543210 = GetFoo3a a0123456789876543210
     instance SuppressUnusedWarnings GetFoo3aSym0 where
-      suppressUnusedWarnings = snd (((,) GetFoo3aSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) GetFoo3aSym0KindInference ())
     type GetFoo3aSym1 :: Foo3 -> Bool
     type family GetFoo3aSym1 (a0123456789876543210 :: Foo3) :: Bool where
       GetFoo3aSym1 a0123456789876543210 = GetFoo3a a0123456789876543210
@@ -159,139 +159,40 @@
     type GetFoo3a :: Foo3 -> Bool
     type family GetFoo3a (a :: Foo3) :: Bool where
       GetFoo3a (MkFoo3 field _) = field
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
+    type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
                                           -> Foo1 -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Foo1) (a :: Symbol) :: Symbol where
+    type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Foo1) (a :: Symbol) :: Symbol where
       ShowsPrec_0123456789876543210 _ MkFoo1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "MkFoo1") a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo1 ((~>) Symbol Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo1 ((~>) Symbol Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) Foo1 ((~>) Symbol Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Foo1 ((~>) Symbol Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> Foo1 -> (~>) Symbol Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo1) :: (~>) Symbol Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> Foo1 -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo1) (a0123456789876543210 :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PShow Foo1 where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> Foo2 a -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Foo2 a) (a :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210 p_0123456789876543210 (MkFoo2a arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "MkFoo2a ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210
-      ShowsPrec_0123456789876543210 p_0123456789876543210 (MkFoo2b argL_0123456789876543210 argR_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 5))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " `MkFoo2b` ")) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argR_0123456789876543210)))) a_0123456789876543210
-      ShowsPrec_0123456789876543210 p_0123456789876543210 ((:*:) arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "(:*:) ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210
-      ShowsPrec_0123456789876543210 p_0123456789876543210 ((:&:) argL_0123456789876543210 argR_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 5))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " :&: ")) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argR_0123456789876543210)))) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Foo2 a) ((~>) Symbol Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Foo2 a) ((~>) Symbol Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) (Foo2 a) ((~>) Symbol Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (Foo2 a) ((~>) Symbol Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> Foo2 a -> (~>) Symbol Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo2 a) :: (~>) Symbol Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> Foo2 a -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo2 a) (a0123456789876543210 :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
+    type ShowsPrec_0123456789876543210 :: forall a. GHC.Internal.Bignum.Natural.Natural
+                                                    -> Foo2 a -> Symbol -> Symbol
+    type family ShowsPrec_0123456789876543210 @a (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Foo2 a) (a :: Symbol) :: Symbol where
+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (MkFoo2a arg_0123456789876543210 arg_0123456789876543210 :: Foo2 a) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "MkFoo2a ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210
+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (MkFoo2b argL_0123456789876543210 argR_0123456789876543210 :: Foo2 a) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 5))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " `MkFoo2b` ")) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argR_0123456789876543210)))) a_0123456789876543210
+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) ((:*:) arg_0123456789876543210 arg_0123456789876543210 :: Foo2 a) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "(:*:) ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210
+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) ((:&:) argL_0123456789876543210 argR_0123456789876543210 :: Foo2 a) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 5))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " :&: ")) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argR_0123456789876543210)))) a_0123456789876543210
     instance PShow (Foo2 a) where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
+    type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
                                           -> Foo3 -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Foo3) (a :: Symbol) :: Symbol where
+    type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Foo3) (a :: Symbol) :: Symbol where
       ShowsPrec_0123456789876543210 p_0123456789876543210 (MkFoo3 arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "MkFoo3 ")) (Apply (Apply (.@#@$) (Apply ShowCharSym0 '{')) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "getFoo3a = ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 0)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowCommaSpaceSym0) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "(***) = ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 0)) arg_0123456789876543210)) (Apply ShowCharSym0 '}'))))))))) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo3 ((~>) Symbol Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo3 ((~>) Symbol Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) Foo3 ((~>) Symbol Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Foo3 ((~>) Symbol Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> Foo3 -> (~>) Symbol Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo3) :: (~>) Symbol Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> Foo3 -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo3) (a0123456789876543210 :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PShow Foo3 where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
-    infixl 5 :%&:
-    infixl 5 :%*:
-    infixl 5 `SMkFoo2b`
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
+    infixl 5 data :%&:
+    infixl 5 data :%*:
+    infixl 5 data `SMkFoo2b`
     (%***) ::
-      forall (t :: Foo3). Sing t -> Sing (Apply (***@#@$) t :: Bool)
+      (forall (t :: Foo3). Sing t -> Sing ((***) t :: Bool) :: Type)
     sGetFoo3a ::
-      forall (t :: Foo3). Sing t -> Sing (Apply GetFoo3aSym0 t :: Bool)
+      (forall (t :: Foo3). Sing t -> Sing (GetFoo3a t :: Bool) :: Type)
     (%***) (SMkFoo3 _ (sField :: Sing field)) = sField
     sGetFoo3a (SMkFoo3 (sField :: Sing field) _) = sField
     instance SingI ((***@#@$) :: (~>) Foo3 Bool) where
-      sing = (singFun1 @(***@#@$)) (%***)
+      sing = singFun1 @(***@#@$) (%***)
     instance SingI (GetFoo3aSym0 :: (~>) Foo3 Bool) where
-      sing = (singFun1 @GetFoo3aSym0) sGetFoo3a
+      sing = singFun1 @GetFoo3aSym0 sGetFoo3a
     data SFoo1 :: Foo1 -> Type where SMkFoo1 :: SFoo1 (MkFoo1 :: Foo1)
     type instance Sing @Foo1 = SFoo1
     instance SingKind Foo1 where
@@ -311,22 +212,22 @@
     type instance Sing @(Foo2 a) = SFoo2
     instance SingKind a => SingKind (Foo2 a) where
       type Demote (Foo2 a) = Foo2 (Demote a)
-      fromSing (SMkFoo2a b b) = (MkFoo2a (fromSing b)) (fromSing b)
-      fromSing (SMkFoo2b b b) = (MkFoo2b (fromSing b)) (fromSing b)
-      fromSing ((:%*:) b b) = ((:*:) (fromSing b)) (fromSing b)
-      fromSing ((:%&:) b b) = ((:&:) (fromSing b)) (fromSing b)
+      fromSing (SMkFoo2a b b) = MkFoo2a (fromSing b) (fromSing b)
+      fromSing (SMkFoo2b b b) = MkFoo2b (fromSing b) (fromSing b)
+      fromSing ((:%*:) b b) = (:*:) (fromSing b) (fromSing b)
+      fromSing ((:%&:) b b) = (:&:) (fromSing b) (fromSing b)
       toSing (MkFoo2a (b :: Demote a) (b :: Demote a))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkFoo2a c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SMkFoo2a c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing a)
       toSing (MkFoo2b (b :: Demote a) (b :: Demote a))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkFoo2b c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SMkFoo2b c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing a)
       toSing ((:*:) (b :: Demote a) (b :: Demote a))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:%*:) c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing a)
       toSing ((:&:) (b :: Demote a) (b :: Demote a))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%&:) c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:%&:) c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing a)
     data SFoo3 :: Foo3 -> Type
       where
         SMkFoo3 :: forall (n :: Bool) (n :: Bool).
@@ -334,201 +235,208 @@
     type instance Sing @Foo3 = SFoo3
     instance SingKind Foo3 where
       type Demote Foo3 = Foo3
-      fromSing (SMkFoo3 b b) = (MkFoo3 (fromSing b)) (fromSing b)
+      fromSing (SMkFoo3 b b) = MkFoo3 (fromSing b) (fromSing b)
       toSing (MkFoo3 (b :: Demote Bool) (b :: Demote Bool))
-        = case
-              ((,) (toSing b :: SomeSing Bool)) (toSing b :: SomeSing Bool)
-          of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkFoo3 c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SMkFoo3 c c))
+            (toSing b :: SomeSing Bool) (toSing b :: SomeSing Bool)
     instance SShow Foo1 where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: Foo1)
-               (t3 :: Symbol). Sing t1
-                               -> Sing t2
-                                  -> Sing t3
-                                     -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) Foo1 ((~>) Symbol Symbol))
-                                                                                    -> Type) t1) t2) t3)
       sShowsPrec
         _
         SMkFoo1
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "MkFoo1")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "MkFoo1"))
             sA_0123456789876543210
     instance SShow a => SShow (Foo2 a) where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: Foo2 a)
-               (t3 :: Symbol). Sing t1
-                               -> Sing t2
-                                  -> Sing t3
-                                     -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (Foo2 a) ((~>) Symbol Symbol))
-                                                                                    -> Type) t1) t2) t3)
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         (SMkFoo2a (sArg_0123456789876543210 :: Sing arg_0123456789876543210)
                   (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "MkFoo2a "))))
-                   ((applySing
-                       ((applySing ((singFun3 @(.@#@$)) (%.)))
-                          ((applySing
-                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                 (sFromInteger (sing :: Sing 11))))
-                             sArg_0123456789876543210)))
-                      ((applySing
-                          ((applySing ((singFun3 @(.@#@$)) (%.)))
-                             ((singFun1 @ShowSpaceSym0) sShowSpace)))
-                         ((applySing
-                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                (sFromInteger (sing :: Sing 11))))
-                            sArg_0123456789876543210))))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "MkFoo2a ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @(.@#@$) (%.))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun3 @(.@#@$) (%.)) (singFun1 @ShowSpaceSym0 sShowSpace))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210)))))
             sA_0123456789876543210
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         (SMkFoo2b (sArgL_0123456789876543210 :: Sing argL_0123456789876543210)
                   (sArgR_0123456789876543210 :: Sing argR_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 5)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing
-                           ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                              (sFromInteger (sing :: Sing 6))))
-                          sArgL_0123456789876543210)))
-                   ((applySing
-                       ((applySing ((singFun3 @(.@#@$)) (%.)))
-                          ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                             (sing :: Sing " `MkFoo2b` "))))
-                      ((applySing
-                          ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                             (sFromInteger (sing :: Sing 6))))
-                         sArgR_0123456789876543210)))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 5))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (applySing
+                           (singFun3 @ShowsPrecSym0 sShowsPrec)
+                           (sFromInteger (sing :: Sing 6)))
+                        sArgL_0123456789876543210))
+                  (applySing
+                     (applySing
+                        (singFun3 @(.@#@$) (%.))
+                        (applySing
+                           (singFun2 @ShowStringSym0 sShowString)
+                           (sing :: Sing " `MkFoo2b` ")))
+                     (applySing
+                        (applySing
+                           (singFun3 @ShowsPrecSym0 sShowsPrec)
+                           (sFromInteger (sing :: Sing 6)))
+                        sArgR_0123456789876543210))))
             sA_0123456789876543210
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         ((:%*:) (sArg_0123456789876543210 :: Sing arg_0123456789876543210)
                 (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "(:*:) "))))
-                   ((applySing
-                       ((applySing ((singFun3 @(.@#@$)) (%.)))
-                          ((applySing
-                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                 (sFromInteger (sing :: Sing 11))))
-                             sArg_0123456789876543210)))
-                      ((applySing
-                          ((applySing ((singFun3 @(.@#@$)) (%.)))
-                             ((singFun1 @ShowSpaceSym0) sShowSpace)))
-                         ((applySing
-                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                (sFromInteger (sing :: Sing 11))))
-                            sArg_0123456789876543210))))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "(:*:) ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @(.@#@$) (%.))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun3 @(.@#@$) (%.)) (singFun1 @ShowSpaceSym0 sShowSpace))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210)))))
             sA_0123456789876543210
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         ((:%&:) (sArgL_0123456789876543210 :: Sing argL_0123456789876543210)
                 (sArgR_0123456789876543210 :: Sing argR_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 5)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing
-                           ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                              (sFromInteger (sing :: Sing 6))))
-                          sArgL_0123456789876543210)))
-                   ((applySing
-                       ((applySing ((singFun3 @(.@#@$)) (%.)))
-                          ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                             (sing :: Sing " :&: "))))
-                      ((applySing
-                          ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                             (sFromInteger (sing :: Sing 6))))
-                         sArgR_0123456789876543210)))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 5))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (applySing
+                           (singFun3 @ShowsPrecSym0 sShowsPrec)
+                           (sFromInteger (sing :: Sing 6)))
+                        sArgL_0123456789876543210))
+                  (applySing
+                     (applySing
+                        (singFun3 @(.@#@$) (%.))
+                        (applySing
+                           (singFun2 @ShowStringSym0 sShowString) (sing :: Sing " :&: ")))
+                     (applySing
+                        (applySing
+                           (singFun3 @ShowsPrecSym0 sShowsPrec)
+                           (sFromInteger (sing :: Sing 6)))
+                        sArgR_0123456789876543210))))
             sA_0123456789876543210
     instance SShow Bool => SShow Foo3 where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: Foo3)
-               (t3 :: Symbol). Sing t1
-                               -> Sing t2
-                                  -> Sing t3
-                                     -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) Foo3 ((~>) Symbol Symbol))
-                                                                                    -> Type) t1) t2) t3)
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         (SMkFoo3 (sArg_0123456789876543210 :: Sing arg_0123456789876543210)
                  (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "MkFoo3 "))))
-                   ((applySing
-                       ((applySing ((singFun3 @(.@#@$)) (%.)))
-                          ((applySing ((singFun2 @ShowCharSym0) sShowChar))
-                             (sing :: Sing '{'))))
-                      ((applySing
-                          ((applySing ((singFun3 @(.@#@$)) (%.)))
-                             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                                (sing :: Sing "getFoo3a = "))))
-                         ((applySing
-                             ((applySing ((singFun3 @(.@#@$)) (%.)))
-                                ((applySing
-                                    ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                       (sFromInteger (sing :: Sing 0))))
-                                   sArg_0123456789876543210)))
-                            ((applySing
-                                ((applySing ((singFun3 @(.@#@$)) (%.)))
-                                   ((singFun1 @ShowCommaSpaceSym0) sShowCommaSpace)))
-                               ((applySing
-                                   ((applySing ((singFun3 @(.@#@$)) (%.)))
-                                      ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                                         (sing :: Sing "(***) = "))))
-                                  ((applySing
-                                      ((applySing ((singFun3 @(.@#@$)) (%.)))
-                                         ((applySing
-                                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                                (sFromInteger (sing :: Sing 0))))
-                                            sArg_0123456789876543210)))
-                                     ((applySing ((singFun2 @ShowCharSym0) sShowChar))
-                                        (sing :: Sing '}')))))))))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "MkFoo3 ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @(.@#@$) (%.))
+                        (applySing (singFun2 @ShowCharSym0 sShowChar) (sing :: Sing '{')))
+                     (applySing
+                        (applySing
+                           (singFun3 @(.@#@$) (%.))
+                           (applySing
+                              (singFun2 @ShowStringSym0 sShowString)
+                              (sing :: Sing "getFoo3a = ")))
+                        (applySing
+                           (applySing
+                              (singFun3 @(.@#@$) (%.))
+                              (applySing
+                                 (applySing
+                                    (singFun3 @ShowsPrecSym0 sShowsPrec)
+                                    (sFromInteger (sing :: Sing 0)))
+                                 sArg_0123456789876543210))
+                           (applySing
+                              (applySing
+                                 (singFun3 @(.@#@$) (%.))
+                                 (singFun1 @ShowCommaSpaceSym0 sShowCommaSpace))
+                              (applySing
+                                 (applySing
+                                    (singFun3 @(.@#@$) (%.))
+                                    (applySing
+                                       (singFun2 @ShowStringSym0 sShowString)
+                                       (sing :: Sing "(***) = ")))
+                                 (applySing
+                                    (applySing
+                                       (singFun3 @(.@#@$) (%.))
+                                       (applySing
+                                          (applySing
+                                             (singFun3 @ShowsPrecSym0 sShowsPrec)
+                                             (sFromInteger (sing :: Sing 0)))
+                                          sArg_0123456789876543210))
+                                    (applySing
+                                       (singFun2 @ShowCharSym0 sShowChar)
+                                       (sing :: Sing '}'))))))))))
             sA_0123456789876543210
     deriving instance Show (SFoo1 (z :: Foo1))
     deriving instance Data.Singletons.ShowSing.ShowSing a =>
@@ -539,76 +447,76 @@
       sing = SMkFoo1
     instance (SingI n, SingI n) =>
              SingI (MkFoo2a (n :: a) (n :: a)) where
-      sing = (SMkFoo2a sing) sing
+      sing = SMkFoo2a sing sing
     instance SingI n => SingI1 (MkFoo2a (n :: a)) where
       liftSing = SMkFoo2a sing
     instance SingI2 MkFoo2a where
       liftSing2 = SMkFoo2a
     instance SingI (MkFoo2aSym0 :: (~>) a ((~>) a (Foo2 a))) where
-      sing = (singFun2 @MkFoo2aSym0) SMkFoo2a
+      sing = singFun2 @MkFoo2aSym0 SMkFoo2a
     instance SingI d =>
              SingI (MkFoo2aSym1 (d :: a) :: (~>) a (Foo2 a)) where
-      sing = (singFun1 @(MkFoo2aSym1 (d :: a))) (SMkFoo2a (sing @d))
+      sing = singFun1 @(MkFoo2aSym1 (d :: a)) (SMkFoo2a (sing @d))
     instance SingI1 (MkFoo2aSym1 :: a -> (~>) a (Foo2 a)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(MkFoo2aSym1 (d :: a))) (SMkFoo2a s)
+        = singFun1 @(MkFoo2aSym1 (d :: a)) (SMkFoo2a s)
     instance (SingI n, SingI n) =>
              SingI (MkFoo2b (n :: a) (n :: a)) where
-      sing = (SMkFoo2b sing) sing
+      sing = SMkFoo2b sing sing
     instance SingI n => SingI1 (MkFoo2b (n :: a)) where
       liftSing = SMkFoo2b sing
     instance SingI2 MkFoo2b where
       liftSing2 = SMkFoo2b
     instance SingI (MkFoo2bSym0 :: (~>) a ((~>) a (Foo2 a))) where
-      sing = (singFun2 @MkFoo2bSym0) SMkFoo2b
+      sing = singFun2 @MkFoo2bSym0 SMkFoo2b
     instance SingI d =>
              SingI (MkFoo2bSym1 (d :: a) :: (~>) a (Foo2 a)) where
-      sing = (singFun1 @(MkFoo2bSym1 (d :: a))) (SMkFoo2b (sing @d))
+      sing = singFun1 @(MkFoo2bSym1 (d :: a)) (SMkFoo2b (sing @d))
     instance SingI1 (MkFoo2bSym1 :: a -> (~>) a (Foo2 a)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(MkFoo2bSym1 (d :: a))) (SMkFoo2b s)
+        = singFun1 @(MkFoo2bSym1 (d :: a)) (SMkFoo2b s)
     instance (SingI n, SingI n) =>
              SingI ((:*:) (n :: a) (n :: a)) where
-      sing = ((:%*:) sing) sing
+      sing = (:%*:) sing sing
     instance SingI n => SingI1 ((:*:) (n :: a)) where
       liftSing = (:%*:) sing
     instance SingI2 (:*:) where
       liftSing2 = (:%*:)
     instance SingI ((:*:@#@$) :: (~>) a ((~>) a (Foo2 a))) where
-      sing = (singFun2 @(:*:@#@$)) (:%*:)
+      sing = singFun2 @(:*:@#@$) (:%*:)
     instance SingI d =>
              SingI ((:*:@#@$$) (d :: a) :: (~>) a (Foo2 a)) where
-      sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d))
+      sing = singFun1 @((:*:@#@$$) (d :: a)) ((:%*:) (sing @d))
     instance SingI1 ((:*:@#@$$) :: a -> (~>) a (Foo2 a)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) s)
+        = singFun1 @((:*:@#@$$) (d :: a)) ((:%*:) s)
     instance (SingI n, SingI n) =>
              SingI ((:&:) (n :: a) (n :: a)) where
-      sing = ((:%&:) sing) sing
+      sing = (:%&:) sing sing
     instance SingI n => SingI1 ((:&:) (n :: a)) where
       liftSing = (:%&:) sing
     instance SingI2 (:&:) where
       liftSing2 = (:%&:)
     instance SingI ((:&:@#@$) :: (~>) a ((~>) a (Foo2 a))) where
-      sing = (singFun2 @(:&:@#@$)) (:%&:)
+      sing = singFun2 @(:&:@#@$) (:%&:)
     instance SingI d =>
              SingI ((:&:@#@$$) (d :: a) :: (~>) a (Foo2 a)) where
-      sing = (singFun1 @((:&:@#@$$) (d :: a))) ((:%&:) (sing @d))
+      sing = singFun1 @((:&:@#@$$) (d :: a)) ((:%&:) (sing @d))
     instance SingI1 ((:&:@#@$$) :: a -> (~>) a (Foo2 a)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((:&:@#@$$) (d :: a))) ((:%&:) s)
+        = singFun1 @((:&:@#@$$) (d :: a)) ((:%&:) s)
     instance (SingI n, SingI n) =>
              SingI (MkFoo3 (n :: Bool) (n :: Bool)) where
-      sing = (SMkFoo3 sing) sing
+      sing = SMkFoo3 sing sing
     instance SingI n => SingI1 (MkFoo3 (n :: Bool)) where
       liftSing = SMkFoo3 sing
     instance SingI2 MkFoo3 where
       liftSing2 = SMkFoo3
     instance SingI (MkFoo3Sym0 :: (~>) Bool ((~>) Bool Foo3)) where
-      sing = (singFun2 @MkFoo3Sym0) SMkFoo3
+      sing = singFun2 @MkFoo3Sym0 SMkFoo3
     instance SingI d =>
              SingI (MkFoo3Sym1 (d :: Bool) :: (~>) Bool Foo3) where
-      sing = (singFun1 @(MkFoo3Sym1 (d :: Bool))) (SMkFoo3 (sing @d))
+      sing = singFun1 @(MkFoo3Sym1 (d :: Bool)) (SMkFoo3 (sing @d))
     instance SingI1 (MkFoo3Sym1 :: Bool -> (~>) Bool Foo3) where
       liftSing (s :: Sing (d :: Bool))
-        = (singFun1 @(MkFoo3Sym1 (d :: Bool))) (SMkFoo3 s)
+        = singFun1 @(MkFoo3Sym1 (d :: Bool)) (SMkFoo3 s)
diff --git a/tests/compile-and-dump/Singletons/StandaloneDeriving.golden b/tests/compile-and-dump/Singletons/StandaloneDeriving.golden
--- a/tests/compile-and-dump/Singletons/StandaloneDeriving.golden
+++ b/tests/compile-and-dump/Singletons/StandaloneDeriving.golden
@@ -30,278 +30,118 @@
       where
         (::*:@#@$###) :: SameKind (Apply (:*:@#@$) arg) ((:*:@#@$$) arg) =>
                          (:*:@#@$) a0123456789876543210
-    type instance Apply (:*:@#@$) a0123456789876543210 = (:*:@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) b (T a b)) (:*:@#@$) a0123456789876543210 = (:*:@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:*:@#@$) where
-      suppressUnusedWarnings = snd (((,) (::*:@#@$###)) ())
-    infixl 6 :*:@#@$
+      suppressUnusedWarnings = snd ((,) (::*:@#@$###) ())
+    infixl 6 type :*:@#@$
     type (:*:@#@$$) :: forall a b. a -> (~>) b (T a b)
     data (:*:@#@$$) (a0123456789876543210 :: a) :: (~>) b (T a b)
       where
         (::*:@#@$$###) :: SameKind (Apply ((:*:@#@$$) a0123456789876543210) arg) ((:*:@#@$$$) a0123456789876543210 arg) =>
                           (:*:@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:*:@#@$$) a0123456789876543210) a0123456789876543210 = (:*:) a0123456789876543210 a0123456789876543210
+    type instance Apply @b @(T a b) ((:*:@#@$$) a0123456789876543210) a0123456789876543210 = (:*:) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:*:@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::*:@#@$$###)) ())
-    infixl 6 :*:@#@$$
+      suppressUnusedWarnings = snd ((,) (::*:@#@$$###) ())
+    infixl 6 type :*:@#@$$
     type (:*:@#@$$$) :: forall a b. a -> b -> T a b
-    type family (:*:@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: T a b where
+    type family (:*:@#@$$$) @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: T a b where
       (:*:@#@$$$) a0123456789876543210 a0123456789876543210 = (:*:) a0123456789876543210 a0123456789876543210
-    infixl 6 :*:@#@$$$
+    infixl 6 type :*:@#@$$$
     type S1Sym0 :: S
     type family S1Sym0 :: S where
       S1Sym0 = S1
     type S2Sym0 :: S
     type family S2Sym0 :: S where
       S2Sym0 = S2
-    type TFHelper_0123456789876543210 :: T a () -> T a () -> Bool
-    type family TFHelper_0123456789876543210 (a :: T a ()) (a :: T a ()) :: Bool where
-      TFHelper_0123456789876543210 ((:*:) a_0123456789876543210 a_0123456789876543210) ((:*:) b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)
-    type TFHelper_0123456789876543210Sym0 :: (~>) (T a ()) ((~>) (T a ()) Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) (T a ()) ((~>) (T a ()) Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: T a ()
-                                             -> (~>) (T a ()) Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: T a ()) :: (~>) (T a ()) Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: T a () -> T a () -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: T a ()) (a0123456789876543210 :: T a ()) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
+    type TFHelper_0123456789876543210 :: forall a. T a ()
+                                                   -> T a () -> Bool
+    type family TFHelper_0123456789876543210 @a (a :: T a ()) (a :: T a ()) :: Bool where
+      TFHelper_0123456789876543210 @a ((:*:) a_0123456789876543210 a_0123456789876543210 :: T a ()) ((:*:) b_0123456789876543210 b_0123456789876543210 :: T a ()) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)
     instance PEq (T a ()) where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type Compare_0123456789876543210 :: T a () -> T a () -> Ordering
-    type family Compare_0123456789876543210 (a :: T a ()) (a :: T a ()) :: Ordering where
-      Compare_0123456789876543210 ((:*:) a_0123456789876543210 a_0123456789876543210) ((:*:) b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))
-    type Compare_0123456789876543210Sym0 :: (~>) (T a ()) ((~>) (T a ()) Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) (T a ()) ((~>) (T a ()) Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: T a ()
-                                            -> (~>) (T a ()) Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: T a ()) :: (~>) (T a ()) Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: T a ()
-                                            -> T a () -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: T a ()) (a0123456789876543210 :: T a ()) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
+      type (==) a a = TFHelper_0123456789876543210 a a
+    type Compare_0123456789876543210 :: forall a. T a ()
+                                                  -> T a () -> Ordering
+    type family Compare_0123456789876543210 @a (a :: T a ()) (a :: T a ()) :: Ordering where
+      Compare_0123456789876543210 @a ((:*:) a_0123456789876543210 a_0123456789876543210 :: T a ()) ((:*:) b_0123456789876543210 b_0123456789876543210 :: T a ()) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))
     instance POrd (T a ()) where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> T a () -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: T a ()) (a :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210 p_0123456789876543210 ((:*:) argL_0123456789876543210 argR_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 6))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 7)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " :*: ")) (Apply (Apply ShowsPrecSym0 (FromInteger 7)) argR_0123456789876543210)))) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (T a ()) ((~>) Symbol Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (T a ()) ((~>) Symbol Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) (T a ()) ((~>) Symbol Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (T a ()) ((~>) Symbol Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> T a () -> (~>) Symbol Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: T a ()) :: (~>) Symbol Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> T a () -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: T a ()) (a0123456789876543210 :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+      type Compare a a = Compare_0123456789876543210 a a
+    type ShowsPrec_0123456789876543210 :: forall a. GHC.Internal.Bignum.Natural.Natural
+                                                    -> T a () -> Symbol -> Symbol
+    type family ShowsPrec_0123456789876543210 @a (a :: GHC.Internal.Bignum.Natural.Natural) (a :: T a ()) (a :: Symbol) :: Symbol where
+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) ((:*:) argL_0123456789876543210 argR_0123456789876543210 :: T a ()) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 6))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 7)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " :*: ")) (Apply (Apply ShowsPrecSym0 (FromInteger 7)) argR_0123456789876543210)))) a_0123456789876543210
     instance PShow (T a ()) where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
     type TFHelper_0123456789876543210 :: S -> S -> Bool
     type family TFHelper_0123456789876543210 (a :: S) (a :: S) :: Bool where
       TFHelper_0123456789876543210 S1 S1 = TrueSym0
       TFHelper_0123456789876543210 S1 S2 = FalseSym0
       TFHelper_0123456789876543210 S2 S1 = FalseSym0
       TFHelper_0123456789876543210 S2 S2 = TrueSym0
-    type TFHelper_0123456789876543210Sym0 :: (~>) S ((~>) S Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) S ((~>) S Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: S -> (~>) S Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: S) :: (~>) S Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: S -> S -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: S) (a0123456789876543210 :: S) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PEq S where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
+      type (==) a a = TFHelper_0123456789876543210 a a
     type Compare_0123456789876543210 :: S -> S -> Ordering
     type family Compare_0123456789876543210 (a :: S) (a :: S) :: Ordering where
-      Compare_0123456789876543210 S1 S1 = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
-      Compare_0123456789876543210 S2 S2 = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
+      Compare_0123456789876543210 S1 S1 = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
+      Compare_0123456789876543210 S2 S2 = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
       Compare_0123456789876543210 S1 S2 = LTSym0
       Compare_0123456789876543210 S2 S1 = GTSym0
-    type Compare_0123456789876543210Sym0 :: (~>) S ((~>) S Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) S ((~>) S Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: S -> (~>) S Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: S) :: (~>) S Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: S -> S -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: S) (a0123456789876543210 :: S) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance POrd S where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
+      type Compare a a = Compare_0123456789876543210 a a
+    type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
                                           -> S -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: S) (a :: Symbol) :: Symbol where
+    type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: S) (a :: Symbol) :: Symbol where
       ShowsPrec_0123456789876543210 _ S1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "S1") a_0123456789876543210
       ShowsPrec_0123456789876543210 _ S2 a_0123456789876543210 = Apply (Apply ShowStringSym0 "S2") a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) S ((~>) Symbol Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) S ((~>) Symbol Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) S ((~>) Symbol Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) S ((~>) Symbol Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> S -> (~>) Symbol Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: S) :: (~>) Symbol Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> S -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: S) (a0123456789876543210 :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PShow S where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
     type MinBound_0123456789876543210 :: S
     type family MinBound_0123456789876543210 :: S where
       MinBound_0123456789876543210 = S1Sym0
-    type MinBound_0123456789876543210Sym0 :: S
-    type family MinBound_0123456789876543210Sym0 :: S where
-      MinBound_0123456789876543210Sym0 = MinBound_0123456789876543210
     type MaxBound_0123456789876543210 :: S
     type family MaxBound_0123456789876543210 :: S where
       MaxBound_0123456789876543210 = S2Sym0
-    type MaxBound_0123456789876543210Sym0 :: S
-    type family MaxBound_0123456789876543210Sym0 :: S where
-      MaxBound_0123456789876543210Sym0 = MaxBound_0123456789876543210
     instance PBounded S where
-      type MinBound = MinBound_0123456789876543210Sym0
-      type MaxBound = MaxBound_0123456789876543210Sym0
-    type family Case_0123456789876543210 n t where
-      Case_0123456789876543210 n 'True = S2Sym0
-      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"
-    type family Case_0123456789876543210 n t where
-      Case_0123456789876543210 n 'True = S1Sym0
-      Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1))
-    type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> S
-    type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: S where
-      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0))
-    type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural S
-    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural S
+      type MinBound = MinBound_0123456789876543210
+      type MaxBound = MaxBound_0123456789876543210
+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 n 'True = S2Sym0
+      LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"
+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
       where
-        ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>
-                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())
-    type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> S
-    type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: S where
-      ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210
-    type FromEnum_0123456789876543210 :: S -> GHC.Num.Natural.Natural
-    type family FromEnum_0123456789876543210 (a :: S) :: GHC.Num.Natural.Natural where
-      FromEnum_0123456789876543210 S1 = FromInteger 0
-      FromEnum_0123456789876543210 S2 = FromInteger 1
-    type FromEnum_0123456789876543210Sym0 :: (~>) S GHC.Num.Natural.Natural
-    data FromEnum_0123456789876543210Sym0 :: (~>) S GHC.Num.Natural.Natural
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 n 'True = S1Sym0
+      LamCases_0123456789876543210 n 'False = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 1))
+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
       where
-        FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>
-                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())
-    type FromEnum_0123456789876543210Sym1 :: S
-                                             -> GHC.Num.Natural.Natural
-    type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: S) :: GHC.Num.Natural.Natural where
-      FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                       -> S
+    type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: S where
+      ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0))
+    type FromEnum_0123456789876543210 :: S
+                                         -> GHC.Internal.Bignum.Natural.Natural
+    type family FromEnum_0123456789876543210 (a :: S) :: GHC.Internal.Bignum.Natural.Natural where
+      FromEnum_0123456789876543210 S1 = FromInteger 0
+      FromEnum_0123456789876543210 S2 = FromInteger 1
     instance PEnum S where
-      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a
-      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a
-    infixl 6 :%*:
+      type ToEnum a = ToEnum_0123456789876543210 a
+      type FromEnum a = FromEnum_0123456789876543210 a
+    infixl 6 data :%*:
     data ST :: forall a b. T a b -> Type
       where
         (:%*:) :: forall a b (n :: a) (n :: b).
@@ -309,10 +149,10 @@
     type instance Sing @(T a b) = ST
     instance (SingKind a, SingKind b) => SingKind (T a b) where
       type Demote (T a b) = T (Demote a) (Demote b)
-      fromSing ((:%*:) b b) = ((:*:) (fromSing b)) (fromSing b)
+      fromSing ((:%*:) b b) = (:*:) (fromSing b) (fromSing b)
       toSing ((:*:) (b :: Demote a) (b :: Demote b))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:%*:) c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
     data SS :: S -> Type
       where
         SS1 :: SS (S1 :: S)
@@ -325,223 +165,196 @@
       toSing S1 = SomeSing SS1
       toSing S2 = SomeSing SS2
     instance SEq a => SEq (T a ()) where
-      (%==) ::
-        forall (t1 :: T a ()) (t2 :: T a ()). Sing t1
-                                              -> Sing t2
-                                                 -> Sing (Apply (Apply ((==@#@$) :: TyFun (T a ()) ((~>) (T a ()) Bool)
-                                                                                    -> Type) t1) t2)
       (%==)
         ((:%*:) (sA_0123456789876543210 :: Sing a_0123456789876543210)
                 (sA_0123456789876543210 :: Sing a_0123456789876543210))
         ((:%*:) (sB_0123456789876543210 :: Sing b_0123456789876543210)
                 (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                ((applySing
-                    ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                   sB_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @(&&@#@$) (%&&))
+               (applySing
+                  (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                  sB_0123456789876543210))
+            (applySing
+               (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
                sB_0123456789876543210)
     instance SOrd a => SOrd (T a ()) where
-      sCompare ::
-        forall (t1 :: T a ()) (t2 :: T a ()). Sing t1
-                                              -> Sing t2
-                                                 -> Sing (Apply (Apply (CompareSym0 :: TyFun (T a ()) ((~>) (T a ()) Ordering)
-                                                                                       -> Type) t1) t2)
       sCompare
         ((:%*:) (sA_0123456789876543210 :: Sing a_0123456789876543210)
                 (sA_0123456789876543210 :: Sing a_0123456789876543210))
         ((:%*:) (sB_0123456789876543210 :: Sing b_0123456789876543210)
                 (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(:@#@$)) SCons))
-                      ((applySing
-                          ((applySing ((singFun2 @CompareSym0) sCompare))
-                             sA_0123456789876543210))
-                         sB_0123456789876543210)))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(:@#@$) SCons)
+                     (applySing
+                        (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                        sB_0123456789876543210))
                   SNil))
     instance SShow a => SShow (T a ()) where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: T a ())
-               (t3 :: Symbol). Sing t1
-                               -> Sing t2
-                                  -> Sing t3
-                                     -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (T a ()) ((~>) Symbol Symbol))
-                                                                                    -> Type) t1) t2) t3)
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         ((:%*:) (sArgL_0123456789876543210 :: Sing argL_0123456789876543210)
                 (sArgR_0123456789876543210 :: Sing argR_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 6)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing
-                           ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                              (sFromInteger (sing :: Sing 7))))
-                          sArgL_0123456789876543210)))
-                   ((applySing
-                       ((applySing ((singFun3 @(.@#@$)) (%.)))
-                          ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                             (sing :: Sing " :*: "))))
-                      ((applySing
-                          ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                             (sFromInteger (sing :: Sing 7))))
-                         sArgR_0123456789876543210)))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 6))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (applySing
+                           (singFun3 @ShowsPrecSym0 sShowsPrec)
+                           (sFromInteger (sing :: Sing 7)))
+                        sArgL_0123456789876543210))
+                  (applySing
+                     (applySing
+                        (singFun3 @(.@#@$) (%.))
+                        (applySing
+                           (singFun2 @ShowStringSym0 sShowString) (sing :: Sing " :*: ")))
+                     (applySing
+                        (applySing
+                           (singFun3 @ShowsPrecSym0 sShowsPrec)
+                           (sFromInteger (sing :: Sing 7)))
+                        sArgR_0123456789876543210))))
             sA_0123456789876543210
     instance SEq S where
-      (%==) ::
-        forall (t1 :: S) (t2 :: S). Sing t1
-                                    -> Sing t2
-                                       -> Sing (Apply (Apply ((==@#@$) :: TyFun S ((~>) S Bool)
-                                                                          -> Type) t1) t2)
       (%==) SS1 SS1 = STrue
       (%==) SS1 SS2 = SFalse
       (%==) SS2 SS1 = SFalse
       (%==) SS2 SS2 = STrue
     instance SOrd S where
-      sCompare ::
-        forall (t1 :: S) (t2 :: S). Sing t1
-                                    -> Sing t2
-                                       -> Sing (Apply (Apply (CompareSym0 :: TyFun S ((~>) S Ordering)
-                                                                             -> Type) t1) t2)
       sCompare SS1 SS1
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
             SNil
       sCompare SS2 SS2
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
             SNil
       sCompare SS1 SS2 = SLT
       sCompare SS2 SS1 = SGT
     instance SShow S where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: S)
-               (t3 :: Symbol). Sing t1
-                               -> Sing t2
-                                  -> Sing t3
-                                     -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) S ((~>) Symbol Symbol))
-                                                                                    -> Type) t1) t2) t3)
       sShowsPrec
         _
         SS1
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "S1")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "S1"))
             sA_0123456789876543210
       sShowsPrec
         _
         SS2
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "S2")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "S2"))
             sA_0123456789876543210
     instance SBounded S where
-      sMinBound :: Sing (MinBoundSym0 :: S)
-      sMaxBound :: Sing (MaxBoundSym0 :: S)
       sMinBound = SS1
       sMaxBound = SS2
     instance SEnum S where
-      sToEnum ::
-        forall (t :: GHC.Num.Natural.Natural). Sing t
-                                               -> Sing (Apply (ToEnumSym0 :: TyFun GHC.Num.Natural.Natural S
-                                                                             -> Type) t)
-      sFromEnum ::
-        forall (t :: S). Sing t
-                         -> Sing (Apply (FromEnumSym0 :: TyFun S GHC.Num.Natural.Natural
-                                                         -> Type) t)
       sToEnum (sN :: Sing n)
-        = (id
-             @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)))))
-            (case
-                 (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))
-                   (sFromInteger (sing :: Sing 0))
-             of
-               STrue -> SS1
-               SFalse
-                 -> (id
-                       @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1)))))
-                      (case
-                           (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))
-                             (sFromInteger (sing :: Sing 1))
-                       of
-                         STrue -> SS2
-                         SFalse -> sError (sing :: Sing "toEnum: bad argument")))
+        = applySing
+            (singFun1
+               @(LamCases_0123456789876543210Sym0 n)
+               (\cases
+                  STrue -> SS1
+                  SFalse
+                    -> applySing
+                         (singFun1
+                            @(LamCases_0123456789876543210Sym0 n)
+                            (\cases
+                               STrue -> SS2
+                               SFalse
+                                 -> applySing
+                                      (singFun1 @ErrorSym0 sError)
+                                      (sing :: Sing "toEnum: bad argument")))
+                         (applySing
+                            (applySing (singFun2 @(==@#@$) (%==)) sN)
+                            (sFromInteger (sing :: Sing 1)))))
+            (applySing
+               (applySing (singFun2 @(==@#@$) (%==)) sN)
+               (sFromInteger (sing :: Sing 0)))
       sFromEnum SS1 = sFromInteger (sing :: Sing 0)
       sFromEnum SS2 = sFromInteger (sing :: Sing 1)
     instance SDecide a => SDecide (T a ()) where
       (%~) ((:%*:) a a) ((:%*:) b b)
-        = case ((,) (((%~) a) b)) (((%~) a) b) of
-            (,) (Proved Refl) (Proved Refl) -> Proved Refl
-            (,) (Disproved contra) _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,) _ (Disproved contra)
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
+        = (\cases
+             (Proved Refl) (Proved Refl) -> Proved Refl
+             (Disproved contra) _ -> Disproved (\cases Refl -> contra Refl)
+             _ (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b) ((%~) a b)
+    instance Eq (ST (z :: T a ())) where
+      (==) _ _ = True
     instance SDecide a =>
-             Data.Type.Equality.TestEquality (ST :: T a () -> Type) where
-      Data.Type.Equality.testEquality
+             GHC.Internal.Data.Type.Equality.TestEquality (ST :: T a ()
+                                                                 -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
         = Data.Singletons.Decide.decideEquality
     instance SDecide a =>
-             Data.Type.Coercion.TestCoercion (ST :: T a () -> Type) where
-      Data.Type.Coercion.testCoercion
+             GHC.Internal.Data.Type.Coercion.TestCoercion (ST :: T a ()
+                                                                 -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
         = Data.Singletons.Decide.decideCoercion
     instance SDecide S where
       (%~) SS1 SS1 = Proved Refl
-      (%~) SS1 SS2 = Disproved (\ x -> case x of {})
-      (%~) SS2 SS1 = Disproved (\ x -> case x of {})
+      (%~) SS1 SS2 = Disproved (\case)
+      (%~) SS2 SS1 = Disproved (\case)
       (%~) SS2 SS2 = Proved Refl
-    instance Data.Type.Equality.TestEquality (SS :: S -> Type) where
-      Data.Type.Equality.testEquality
+    instance Eq (SS (z :: S)) where
+      (==) _ _ = True
+    instance GHC.Internal.Data.Type.Equality.TestEquality (SS :: S
+                                                                 -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
         = Data.Singletons.Decide.decideEquality
-    instance Data.Type.Coercion.TestCoercion (SS :: S -> Type) where
-      Data.Type.Coercion.testCoercion
+    instance GHC.Internal.Data.Type.Coercion.TestCoercion (SS :: S
+                                                                 -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
         = Data.Singletons.Decide.decideCoercion
+    instance Ord (ST (z :: T a ())) where
+      compare _ _ = EQ
+    instance Ord (SS (z :: S)) where
+      compare _ _ = EQ
     deriving instance Data.Singletons.ShowSing.ShowSing a =>
                       Show (ST (z :: T a ()))
     deriving instance Show (SS (z :: S))
     instance (SingI n, SingI n) =>
              SingI ((:*:) (n :: a) (n :: b)) where
-      sing = ((:%*:) sing) sing
+      sing = (:%*:) sing sing
     instance SingI n => SingI1 ((:*:) (n :: a)) where
       liftSing = (:%*:) sing
     instance SingI2 (:*:) where
       liftSing2 = (:%*:)
     instance SingI ((:*:@#@$) :: (~>) a ((~>) b (T a b))) where
-      sing = (singFun2 @(:*:@#@$)) (:%*:)
+      sing = singFun2 @(:*:@#@$) (:%*:)
     instance SingI d =>
              SingI ((:*:@#@$$) (d :: a) :: (~>) b (T a b)) where
-      sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d))
+      sing = singFun1 @((:*:@#@$$) (d :: a)) ((:%*:) (sing @d))
     instance SingI1 ((:*:@#@$$) :: a -> (~>) b (T a b)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) s)
+        = singFun1 @((:*:@#@$$) (d :: a)) ((:%*:) s)
     instance SingI S1 where
       sing = SS1
     instance SingI S2 where
diff --git a/tests/compile-and-dump/Singletons/Star.golden b/tests/compile-and-dump/Singletons/Star.golden
--- a/tests/compile-and-dump/Singletons/Star.golden
+++ b/tests/compile-and-dump/Singletons/Star.golden
@@ -23,9 +23,9 @@
       where
         MaybeSym0KindInference :: SameKind (Apply MaybeSym0 arg) (MaybeSym1 arg) =>
                                   MaybeSym0 a0123456789876543210
-    type instance Apply MaybeSym0 a0123456789876543210 = Maybe a0123456789876543210
+    type instance Apply @Type @Type MaybeSym0 a0123456789876543210 = Maybe a0123456789876543210
     instance SuppressUnusedWarnings MaybeSym0 where
-      suppressUnusedWarnings = snd (((,) MaybeSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MaybeSym0KindInference ())
     type MaybeSym1 :: Type -> Type
     type family MaybeSym1 (a0123456789876543210 :: Type) :: Type where
       MaybeSym1 a0123456789876543210 = Maybe a0123456789876543210
@@ -34,17 +34,17 @@
       where
         VecSym0KindInference :: SameKind (Apply VecSym0 arg) (VecSym1 arg) =>
                                 VecSym0 a0123456789876543210
-    type instance Apply VecSym0 a0123456789876543210 = VecSym1 a0123456789876543210
+    type instance Apply @Type @((~>) Nat Type) VecSym0 a0123456789876543210 = VecSym1 a0123456789876543210
     instance SuppressUnusedWarnings VecSym0 where
-      suppressUnusedWarnings = snd (((,) VecSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) VecSym0KindInference ())
     type VecSym1 :: Type -> (~>) Nat Type
     data VecSym1 (a0123456789876543210 :: Type) :: (~>) Nat Type
       where
         VecSym1KindInference :: SameKind (Apply (VecSym1 a0123456789876543210) arg) (VecSym2 a0123456789876543210 arg) =>
                                 VecSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (VecSym1 a0123456789876543210) a0123456789876543210 = Vec a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Type (VecSym1 a0123456789876543210) a0123456789876543210 = Vec a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (VecSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) VecSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) VecSym1KindInference ())
     type VecSym2 :: Type -> Nat -> Type
     type family VecSym2 (a0123456789876543210 :: Type) (a0123456789876543210 :: Nat) :: Type where
       VecSym2 a0123456789876543210 a0123456789876543210 = Vec a0123456789876543210 a0123456789876543210
@@ -75,36 +75,15 @@
       TFHelper_0123456789876543210 (Vec _ _) String = FalseSym0
       TFHelper_0123456789876543210 (Vec _ _) (Maybe _) = FalseSym0
       TFHelper_0123456789876543210 (Vec a_0123456789876543210 a_0123456789876543210) (Vec b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)
-    type TFHelper_0123456789876543210Sym0 :: (~>) Type ((~>) Type Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) Type ((~>) Type Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Type -> (~>) Type Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Type) :: (~>) Type Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Type -> Type -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Type) (a0123456789876543210 :: Type) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PEq Type where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
+      type (==) a a = TFHelper_0123456789876543210 a a
     type Compare_0123456789876543210 :: Type -> Type -> Ordering
     type family Compare_0123456789876543210 (a :: Type) (a :: Type) :: Ordering where
-      Compare_0123456789876543210 Nat Nat = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
-      Compare_0123456789876543210 Int Int = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
-      Compare_0123456789876543210 String String = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
-      Compare_0123456789876543210 (Maybe a_0123456789876543210) (Maybe b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
-      Compare_0123456789876543210 (Vec a_0123456789876543210 a_0123456789876543210) (Vec b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))
+      Compare_0123456789876543210 Nat Nat = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
+      Compare_0123456789876543210 Int Int = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
+      Compare_0123456789876543210 String String = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
+      Compare_0123456789876543210 (Maybe a_0123456789876543210) (Maybe b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
+      Compare_0123456789876543210 (Vec a_0123456789876543210 a_0123456789876543210) (Vec b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0))
       Compare_0123456789876543210 Nat Int = LTSym0
       Compare_0123456789876543210 Nat String = LTSym0
       Compare_0123456789876543210 Nat (Maybe _) = LTSym0
@@ -125,72 +104,18 @@
       Compare_0123456789876543210 (Vec _ _) Int = GTSym0
       Compare_0123456789876543210 (Vec _ _) String = GTSym0
       Compare_0123456789876543210 (Vec _ _) (Maybe _) = GTSym0
-    type Compare_0123456789876543210Sym0 :: (~>) Type ((~>) Type Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) Type ((~>) Type Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: Type -> (~>) Type Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Type) :: (~>) Type Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: Type -> Type -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: Type) (a0123456789876543210 :: Type) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance POrd Type where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
+      type Compare a a = Compare_0123456789876543210 a a
+    type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
                                           -> Type -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Type) (a :: Symbol) :: Symbol where
+    type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Type) (a :: Symbol) :: Symbol where
       ShowsPrec_0123456789876543210 _ Nat a_0123456789876543210 = Apply (Apply ShowStringSym0 "Nat") a_0123456789876543210
       ShowsPrec_0123456789876543210 _ Int a_0123456789876543210 = Apply (Apply ShowStringSym0 "Int") a_0123456789876543210
       ShowsPrec_0123456789876543210 _ String a_0123456789876543210 = Apply (Apply ShowStringSym0 "String") a_0123456789876543210
       ShowsPrec_0123456789876543210 p_0123456789876543210 (Maybe arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Maybe ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210
       ShowsPrec_0123456789876543210 p_0123456789876543210 (Vec arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Vec ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Type ((~>) Symbol Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Type ((~>) Symbol Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) Type ((~>) Symbol Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Type ((~>) Symbol Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> Type -> (~>) Symbol Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Type) :: (~>) Symbol Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> Type -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Type) (a0123456789876543210 :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PShow Type where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
     data SRep :: Type -> Type
       where
         SNat :: SRep (Nat :: Type)
@@ -206,67 +131,62 @@
       fromSing SInt = Singletons.Star.Int
       fromSing SString = Singletons.Star.String
       fromSing (SMaybe b) = Singletons.Star.Maybe (fromSing b)
-      fromSing (SVec b b)
-        = (Singletons.Star.Vec (fromSing b)) (fromSing b)
+      fromSing (SVec b b) = Singletons.Star.Vec (fromSing b) (fromSing b)
       toSing Singletons.Star.Nat = SomeSing SNat
       toSing Singletons.Star.Int = SomeSing SInt
       toSing Singletons.Star.String = SomeSing SString
       toSing (Singletons.Star.Maybe (b :: Demote Type))
-        = case toSing b :: SomeSing Type of
-            SomeSing c -> SomeSing (SMaybe c)
+        = (\cases (SomeSing c) -> SomeSing (SMaybe c))
+            (toSing b :: SomeSing Type)
       toSing (Singletons.Star.Vec (b :: Demote Type) (b :: Demote Nat))
-        = case
-              ((,) (toSing b :: SomeSing Type)) (toSing b :: SomeSing Nat)
-          of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SVec c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SVec c c))
+            (toSing b :: SomeSing Type) (toSing b :: SomeSing Nat)
     instance (SDecide Type, SDecide Nat) => SDecide Type where
       (%~) SNat SNat = Proved Refl
-      (%~) SNat SInt = Disproved (\ x -> case x of {})
-      (%~) SNat SString = Disproved (\ x -> case x of {})
-      (%~) SNat (SMaybe _) = Disproved (\ x -> case x of {})
-      (%~) SNat (SVec _ _) = Disproved (\ x -> case x of {})
-      (%~) SInt SNat = Disproved (\ x -> case x of {})
+      (%~) SNat SInt = Disproved (\case)
+      (%~) SNat SString = Disproved (\case)
+      (%~) SNat (SMaybe _) = Disproved (\case)
+      (%~) SNat (SVec _ _) = Disproved (\case)
+      (%~) SInt SNat = Disproved (\case)
       (%~) SInt SInt = Proved Refl
-      (%~) SInt SString = Disproved (\ x -> case x of {})
-      (%~) SInt (SMaybe _) = Disproved (\ x -> case x of {})
-      (%~) SInt (SVec _ _) = Disproved (\ x -> case x of {})
-      (%~) SString SNat = Disproved (\ x -> case x of {})
-      (%~) SString SInt = Disproved (\ x -> case x of {})
+      (%~) SInt SString = Disproved (\case)
+      (%~) SInt (SMaybe _) = Disproved (\case)
+      (%~) SInt (SVec _ _) = Disproved (\case)
+      (%~) SString SNat = Disproved (\case)
+      (%~) SString SInt = Disproved (\case)
       (%~) SString SString = Proved Refl
-      (%~) SString (SMaybe _) = Disproved (\ x -> case x of {})
-      (%~) SString (SVec _ _) = Disproved (\ x -> case x of {})
-      (%~) (SMaybe _) SNat = Disproved (\ x -> case x of {})
-      (%~) (SMaybe _) SInt = Disproved (\ x -> case x of {})
-      (%~) (SMaybe _) SString = Disproved (\ x -> case x of {})
+      (%~) SString (SMaybe _) = Disproved (\case)
+      (%~) SString (SVec _ _) = Disproved (\case)
+      (%~) (SMaybe _) SNat = Disproved (\case)
+      (%~) (SMaybe _) SInt = Disproved (\case)
+      (%~) (SMaybe _) SString = Disproved (\case)
       (%~) (SMaybe a) (SMaybe b)
-        = case ((%~) a) b of
-            Proved Refl -> Proved Refl
-            Disproved contra
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-      (%~) (SMaybe _) (SVec _ _) = Disproved (\ x -> case x of {})
-      (%~) (SVec _ _) SNat = Disproved (\ x -> case x of {})
-      (%~) (SVec _ _) SInt = Disproved (\ x -> case x of {})
-      (%~) (SVec _ _) SString = Disproved (\ x -> case x of {})
-      (%~) (SVec _ _) (SMaybe _) = Disproved (\ x -> case x of {})
+        = (\cases
+             (Proved Refl) -> Proved Refl
+             (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b)
+      (%~) (SMaybe _) (SVec _ _) = Disproved (\case)
+      (%~) (SVec _ _) SNat = Disproved (\case)
+      (%~) (SVec _ _) SInt = Disproved (\case)
+      (%~) (SVec _ _) SString = Disproved (\case)
+      (%~) (SVec _ _) (SMaybe _) = Disproved (\case)
       (%~) (SVec a a) (SVec b b)
-        = case ((,) (((%~) a) b)) (((%~) a) b) of
-            (,) (Proved Refl) (Proved Refl) -> Proved Refl
-            (,) (Disproved contra) _
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
-            (,) _ (Disproved contra)
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
+        = (\cases
+             (Proved Refl) (Proved Refl) -> Proved Refl
+             (Disproved contra) _ -> Disproved (\cases Refl -> contra Refl)
+             _ (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b) ((%~) a b)
+    instance Eq (SRep (z :: Type)) where
+      (==) _ _ = True
     instance (SDecide Type, SDecide Nat) =>
-             Data.Type.Equality.TestEquality (SRep :: Type -> Type) where
-      Data.Type.Equality.testEquality = decideEquality
+             GHC.Internal.Data.Type.Equality.TestEquality (SRep :: Type
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality = decideEquality
     instance (SDecide Type, SDecide Nat) =>
-             Data.Type.Coercion.TestCoercion (SRep :: Type -> Type) where
-      Data.Type.Coercion.testCoercion = decideCoercion
+             GHC.Internal.Data.Type.Coercion.TestCoercion (SRep :: Type
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion = decideCoercion
     instance (SEq Type, SEq Nat) => SEq Type where
-      (%==) ::
-        forall (t1 :: Type) (t2 :: Type). Sing t1
-                                          -> Sing t2
-                                             -> Sing (Apply (Apply ((==@#@$) :: TyFun Type ((~>) Type Bool)
-                                                                                -> Type) t1) t2)
       (%==) SNat SNat = STrue
       (%==) SNat SInt = SFalse
       (%==) SNat SString = SFalse
@@ -288,8 +208,8 @@
       (%==)
         (SMaybe (sA_0123456789876543210 :: Sing a_0123456789876543210))
         (SMaybe (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
+        = applySing
+            (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
             sB_0123456789876543210
       (%==) (SMaybe _) (SVec _ _) = SFalse
       (%==) (SVec _ _) SNat = SFalse
@@ -301,78 +221,69 @@
               (sA_0123456789876543210 :: Sing a_0123456789876543210))
         (SVec (sB_0123456789876543210 :: Sing b_0123456789876543210)
               (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(&&@#@$)) (%&&)))
-                ((applySing
-                    ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
-                   sB_0123456789876543210)))
-            ((applySing
-                ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
+        = applySing
+            (applySing
+               (singFun2 @(&&@#@$) (%&&))
+               (applySing
+                  (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
+                  sB_0123456789876543210))
+            (applySing
+               (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
                sB_0123456789876543210)
     instance (SOrd Type, SOrd Nat) => SOrd Type where
-      sCompare ::
-        forall (t1 :: Type) (t2 :: Type). Sing t1
-                                          -> Sing t2
-                                             -> Sing (Apply (Apply (CompareSym0 :: TyFun Type ((~>) Type Ordering)
-                                                                                   -> Type) t1) t2)
       sCompare SNat SNat
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
             SNil
       sCompare SInt SInt
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
             SNil
       sCompare SString SString
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
             SNil
       sCompare
         (SMaybe (sA_0123456789876543210 :: Sing a_0123456789876543210))
         (SMaybe (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
                SNil)
       sCompare
         (SVec (sA_0123456789876543210 :: Sing a_0123456789876543210)
               (sA_0123456789876543210 :: Sing a_0123456789876543210))
         (SVec (sB_0123456789876543210 :: Sing b_0123456789876543210)
               (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
-               ((applySing
-                   ((applySing ((singFun2 @(:@#@$)) SCons))
-                      ((applySing
-                          ((applySing ((singFun2 @CompareSym0) sCompare))
-                             sA_0123456789876543210))
-                         sB_0123456789876543210)))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
+               (applySing
+                  (applySing
+                     (singFun2 @(:@#@$) SCons)
+                     (applySing
+                        (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                        sB_0123456789876543210))
                   SNil))
       sCompare SNat SInt = SLT
       sCompare SNat SString = SLT
@@ -395,85 +306,85 @@
       sCompare (SVec _ _) SString = SGT
       sCompare (SVec _ _) (SMaybe _) = SGT
     instance (SShow Type, SShow Nat) => SShow Type where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: Type)
-               (t3 :: Symbol). Sing t1
-                               -> Sing t2
-                                  -> Sing t3
-                                     -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) Type ((~>) Symbol Symbol))
-                                                                                    -> Type) t1) t2) t3)
       sShowsPrec
         _
         SNat
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "Nat")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Nat"))
             sA_0123456789876543210
       sShowsPrec
         _
         SInt
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "Int")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Int"))
             sA_0123456789876543210
       sShowsPrec
         _
         SString
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "String")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "String"))
             sA_0123456789876543210
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         (SMaybe (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "Maybe "))))
-                   ((applySing
-                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                          (sFromInteger (sing :: Sing 11))))
-                      sArg_0123456789876543210))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Maybe ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @ShowsPrecSym0 sShowsPrec)
+                        (sFromInteger (sing :: Sing 11)))
+                     sArg_0123456789876543210)))
             sA_0123456789876543210
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         (SVec (sArg_0123456789876543210 :: Sing arg_0123456789876543210)
               (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "Vec "))))
-                   ((applySing
-                       ((applySing ((singFun3 @(.@#@$)) (%.)))
-                          ((applySing
-                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                 (sFromInteger (sing :: Sing 11))))
-                             sArg_0123456789876543210)))
-                      ((applySing
-                          ((applySing ((singFun3 @(.@#@$)) (%.)))
-                             ((singFun1 @ShowSpaceSym0) sShowSpace)))
-                         ((applySing
-                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                                (sFromInteger (sing :: Sing 11))))
-                            sArg_0123456789876543210))))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Vec ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @(.@#@$) (%.))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210))
+                     (applySing
+                        (applySing
+                           (singFun3 @(.@#@$) (%.)) (singFun1 @ShowSpaceSym0 sShowSpace))
+                        (applySing
+                           (applySing
+                              (singFun3 @ShowsPrecSym0 sShowsPrec)
+                              (sFromInteger (sing :: Sing 11)))
+                           sArg_0123456789876543210)))))
             sA_0123456789876543210
     instance SingI Nat where
       sing = SNat
@@ -486,19 +397,19 @@
     instance SingI1 Maybe where
       liftSing = SMaybe
     instance SingI (MaybeSym0 :: (~>) Type Type) where
-      sing = (singFun1 @MaybeSym0) SMaybe
+      sing = singFun1 @MaybeSym0 SMaybe
     instance (SingI n, SingI n) =>
              SingI (Vec (n :: Type) (n :: Nat)) where
-      sing = (SVec sing) sing
+      sing = SVec sing sing
     instance SingI n => SingI1 (Vec (n :: Type)) where
       liftSing = SVec sing
     instance SingI2 Vec where
       liftSing2 = SVec
     instance SingI (VecSym0 :: (~>) Type ((~>) Nat Type)) where
-      sing = (singFun2 @VecSym0) SVec
+      sing = singFun2 @VecSym0 SVec
     instance SingI d =>
              SingI (VecSym1 (d :: Type) :: (~>) Nat Type) where
-      sing = (singFun1 @(VecSym1 (d :: Type))) (SVec (sing @d))
+      sing = singFun1 @(VecSym1 (d :: Type)) (SVec (sing @d))
     instance SingI1 (VecSym1 :: Type -> (~>) Nat Type) where
       liftSing (s :: Sing (d :: Type))
-        = (singFun1 @(VecSym1 (d :: Type))) (SVec s)
+        = singFun1 @(VecSym1 (d :: Type)) (SVec s)
diff --git a/tests/compile-and-dump/Singletons/T124.golden b/tests/compile-and-dump/Singletons/T124.golden
--- a/tests/compile-and-dump/Singletons/T124.golden
+++ b/tests/compile-and-dump/Singletons/T124.golden
@@ -12,9 +12,9 @@
       where
         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
                                 FooSym0 a0123456789876543210
-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210
+    type instance Apply @Bool @() FooSym0 a0123456789876543210 = Foo a0123456789876543210
     instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
     type FooSym1 :: Bool -> ()
     type family FooSym1 (a0123456789876543210 :: Bool) :: () where
       FooSym1 a0123456789876543210 = Foo a0123456789876543210
@@ -22,14 +22,15 @@
     type family Foo (a :: Bool) :: () where
       Foo 'True = Tuple0Sym0
       Foo 'False = Tuple0Sym0
-    sFoo :: forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: ())
+    sFoo :: (forall (t :: Bool). Sing t -> Sing (Foo t :: ()) :: Type)
     sFoo STrue = STuple0
     sFoo SFalse = STuple0
     instance SingI (FooSym0 :: (~>) Bool ()) where
-      sing = (singFun1 @FooSym0) sFoo
+      sing = singFun1 @FooSym0 sFoo
 Singletons/T124.hs:0:0:: Splicing expression
     sCases ''Bool [| b |] [| STuple0 |]
   ======>
-    case b of
-      SFalse -> STuple0
-      STrue -> STuple0
+    (\cases
+       SFalse -> STuple0
+       STrue -> STuple0)
+      b
diff --git a/tests/compile-and-dump/Singletons/T136.golden b/tests/compile-and-dump/Singletons/T136.golden
--- a/tests/compile-and-dump/Singletons/T136.golden
+++ b/tests/compile-and-dump/Singletons/T136.golden
@@ -34,147 +34,124 @@
       Succ_0123456789876543210 '[] = Apply (Apply (:@#@$) TrueSym0) NilSym0
       Succ_0123456789876543210 ('(:) 'False as) = Apply (Apply (:@#@$) TrueSym0) as
       Succ_0123456789876543210 ('(:) 'True as) = Apply (Apply (:@#@$) FalseSym0) (Apply SuccSym0 as)
-    type Succ_0123456789876543210Sym0 :: (~>) [Bool] [Bool]
-    data Succ_0123456789876543210Sym0 :: (~>) [Bool] [Bool]
-      where
-        Succ_0123456789876543210Sym0KindInference :: SameKind (Apply Succ_0123456789876543210Sym0 arg) (Succ_0123456789876543210Sym1 arg) =>
-                                                     Succ_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Succ_0123456789876543210Sym0 a0123456789876543210 = Succ_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings Succ_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Succ_0123456789876543210Sym0KindInference) ())
-    type Succ_0123456789876543210Sym1 :: [Bool] -> [Bool]
-    type family Succ_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) :: [Bool] where
-      Succ_0123456789876543210Sym1 a0123456789876543210 = Succ_0123456789876543210 a0123456789876543210
     type Pred_0123456789876543210 :: [Bool] -> [Bool]
     type family Pred_0123456789876543210 (a :: [Bool]) :: [Bool] where
       Pred_0123456789876543210 '[] = Apply ErrorSym0 "pred 0"
       Pred_0123456789876543210 ('(:) 'False as) = Apply (Apply (:@#@$) TrueSym0) (Apply PredSym0 as)
       Pred_0123456789876543210 ('(:) 'True as) = Apply (Apply (:@#@$) FalseSym0) as
-    type Pred_0123456789876543210Sym0 :: (~>) [Bool] [Bool]
-    data Pred_0123456789876543210Sym0 :: (~>) [Bool] [Bool]
+    type family LamCases_0123456789876543210 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 i arg_0123456789876543210 'True = NilSym0
+      LamCases_0123456789876543210 i arg_0123456789876543210 'False = Apply SuccSym0 (Apply ToEnumSym0 (Apply PredSym0 i))
+    data LamCases_0123456789876543210Sym0 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
       where
-        Pred_0123456789876543210Sym0KindInference :: SameKind (Apply Pred_0123456789876543210Sym0 arg) (Pred_0123456789876543210Sym1 arg) =>
-                                                     Pred_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Pred_0123456789876543210Sym0 a0123456789876543210 = Pred_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings Pred_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 i0123456789876543210 arg_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Pred_0123456789876543210Sym0KindInference) ())
-    type Pred_0123456789876543210Sym1 :: [Bool] -> [Bool]
-    type family Pred_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) :: [Bool] where
-      Pred_0123456789876543210Sym1 a0123456789876543210 = Pred_0123456789876543210 a0123456789876543210
-    type family Case_0123456789876543210 i arg_0123456789876543210 t where
-      Case_0123456789876543210 i arg_0123456789876543210 'True = NilSym0
-      Case_0123456789876543210 i arg_0123456789876543210 'False = Apply SuccSym0 (Apply ToEnumSym0 (Apply PredSym0 i))
-    type family Case_0123456789876543210 i arg_0123456789876543210 t where
-      Case_0123456789876543210 i arg_0123456789876543210 'True = Apply ErrorSym0 "negative toEnum"
-      Case_0123456789876543210 i arg_0123456789876543210 'False = Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (==@#@$) i) (FromInteger 0))
-    type family Case_0123456789876543210 arg_0123456789876543210 t where
-      Case_0123456789876543210 arg_0123456789876543210 i = Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (<@#@$) i) (FromInteger 0))
-    type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural
-                                       -> [Bool]
-    type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: [Bool] where
-      ToEnum_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210
-    type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural [Bool]
-    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural [Bool]
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 i arg_0123456789876543210 'True = Apply ErrorSym0 "negative toEnum"
+      LamCases_0123456789876543210 i arg_0123456789876543210 'False = Apply (LamCases_0123456789876543210Sym0 i arg_0123456789876543210) (Apply (Apply (==@#@$) i) (FromInteger 0))
+    data LamCases_0123456789876543210Sym0 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
       where
-        ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>
-                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 i0123456789876543210 arg_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())
-    type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                           -> [Bool]
-    type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: [Bool] where
-      ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 arg_0123456789876543210 i = Apply (LamCases_0123456789876543210Sym0 i arg_0123456789876543210) (Apply (Apply (<@#@$) i) (FromInteger 0))
+    data LamCases_0123456789876543210Sym0 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 arg_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 arg_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 arg_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 arg_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                       -> [Bool]
+    type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: [Bool] where
+      ToEnum_0123456789876543210 arg_0123456789876543210 = Apply (LamCases_0123456789876543210Sym0 arg_0123456789876543210) arg_0123456789876543210
     type FromEnum_0123456789876543210 :: [Bool]
-                                         -> GHC.Num.Natural.Natural
-    type family FromEnum_0123456789876543210 (a :: [Bool]) :: GHC.Num.Natural.Natural where
+                                         -> GHC.Internal.Bignum.Natural.Natural
+    type family FromEnum_0123456789876543210 (a :: [Bool]) :: GHC.Internal.Bignum.Natural.Natural where
       FromEnum_0123456789876543210 '[] = FromInteger 0
       FromEnum_0123456789876543210 ('(:) 'False as) = Apply (Apply (*@#@$) (FromInteger 2)) (Apply FromEnumSym0 as)
       FromEnum_0123456789876543210 ('(:) 'True as) = Apply (Apply (+@#@$) (FromInteger 1)) (Apply (Apply (*@#@$) (FromInteger 2)) (Apply FromEnumSym0 as))
-    type FromEnum_0123456789876543210Sym0 :: (~>) [Bool] GHC.Num.Natural.Natural
-    data FromEnum_0123456789876543210Sym0 :: (~>) [Bool] GHC.Num.Natural.Natural
-      where
-        FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>
-                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())
-    type FromEnum_0123456789876543210Sym1 :: [Bool]
-                                             -> GHC.Num.Natural.Natural
-    type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) :: GHC.Num.Natural.Natural where
-      FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210
     instance PEnum [Bool] where
-      type Succ a = Apply Succ_0123456789876543210Sym0 a
-      type Pred a = Apply Pred_0123456789876543210Sym0 a
-      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a
-      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a
+      type Succ a = Succ_0123456789876543210 a
+      type Pred a = Pred_0123456789876543210 a
+      type ToEnum a = ToEnum_0123456789876543210 a
+      type FromEnum a = FromEnum_0123456789876543210 a
     instance SEnum [Bool] where
-      sSucc ::
-        forall (t :: [Bool]). Sing t
-                              -> Sing (Apply (SuccSym0 :: TyFun [Bool] [Bool] -> Type) t)
-      sPred ::
-        forall (t :: [Bool]). Sing t
-                              -> Sing (Apply (PredSym0 :: TyFun [Bool] [Bool] -> Type) t)
-      sToEnum ::
-        forall (t :: GHC.Num.Natural.Natural). Sing t
-                                               -> Sing (Apply (ToEnumSym0 :: TyFun GHC.Num.Natural.Natural [Bool]
-                                                                             -> Type) t)
-      sFromEnum ::
-        forall (t :: [Bool]). Sing t
-                              -> Sing (Apply (FromEnumSym0 :: TyFun [Bool] GHC.Num.Natural.Natural
-                                                              -> Type) t)
       sSucc SNil
-        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) STrue)) SNil
+        = applySing (applySing (singFun2 @(:@#@$) SCons) STrue) SNil
       sSucc (SCons SFalse (sAs :: Sing as))
-        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) STrue)) sAs
+        = applySing (applySing (singFun2 @(:@#@$) SCons) STrue) sAs
       sSucc (SCons STrue (sAs :: Sing as))
-        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SFalse))
-            ((applySing ((singFun1 @SuccSym0) sSucc)) sAs)
-      sPred SNil = sError (sing :: Sing "pred 0")
+        = applySing
+            (applySing (singFun2 @(:@#@$) SCons) SFalse)
+            (applySing (singFun1 @SuccSym0 sSucc) sAs)
+      sPred SNil
+        = applySing (singFun1 @ErrorSym0 sError) (sing :: Sing "pred 0")
       sPred (SCons SFalse (sAs :: Sing as))
-        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) STrue))
-            ((applySing ((singFun1 @PredSym0) sPred)) sAs)
+        = applySing
+            (applySing (singFun2 @(:@#@$) SCons) STrue)
+            (applySing (singFun1 @PredSym0 sPred) sAs)
       sPred (SCons STrue (sAs :: Sing as))
-        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SFalse)) sAs
+        = applySing (applySing (singFun2 @(:@#@$) SCons) SFalse) sAs
       sToEnum (sArg_0123456789876543210 :: Sing arg_0123456789876543210)
-        = (id
-             @(Sing (Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210)))
-            (case sArg_0123456789876543210 of
-               (sI :: Sing i)
-                 -> (id
-                       @(Sing (Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (<@#@$) i) (FromInteger 0)))))
-                      (case
-                           (applySing ((applySing ((singFun2 @(<@#@$)) (%<))) sI))
-                             (sFromInteger (sing :: Sing 0))
-                       of
-                         STrue -> sError (sing :: Sing "negative toEnum")
-                         SFalse
-                           -> (id
-                                 @(Sing (Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (==@#@$) i) (FromInteger 0)))))
-                                (case
-                                     (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sI))
-                                       (sFromInteger (sing :: Sing 0))
-                                 of
-                                   STrue -> SNil
-                                   SFalse
-                                     -> (applySing ((singFun1 @SuccSym0) sSucc))
-                                          ((applySing ((singFun1 @ToEnumSym0) sToEnum))
-                                             ((applySing ((singFun1 @PredSym0) sPred)) sI)))))
+        = applySing
+            (singFun1
+               @(LamCases_0123456789876543210Sym0 arg_0123456789876543210)
+               (\cases
+                  (sI :: Sing i)
+                    -> applySing
+                         (singFun1
+                            @(LamCases_0123456789876543210Sym0 i arg_0123456789876543210)
+                            (\cases
+                               STrue
+                                 -> applySing
+                                      (singFun1 @ErrorSym0 sError) (sing :: Sing "negative toEnum")
+                               SFalse
+                                 -> applySing
+                                      (singFun1
+                                         @(LamCases_0123456789876543210Sym0 i arg_0123456789876543210)
+                                         (\cases
+                                            STrue -> SNil
+                                            SFalse
+                                              -> applySing
+                                                   (singFun1 @SuccSym0 sSucc)
+                                                   (applySing
+                                                      (singFun1 @ToEnumSym0 sToEnum)
+                                                      (applySing (singFun1 @PredSym0 sPred) sI))))
+                                      (applySing
+                                         (applySing (singFun2 @(==@#@$) (%==)) sI)
+                                         (sFromInteger (sing :: Sing 0)))))
+                         (applySing
+                            (applySing (singFun2 @(<@#@$) (%<)) sI)
+                            (sFromInteger (sing :: Sing 0)))))
+            sArg_0123456789876543210
       sFromEnum SNil = sFromInteger (sing :: Sing 0)
       sFromEnum (SCons SFalse (sAs :: Sing as))
-        = (applySing
-             ((applySing ((singFun2 @(*@#@$)) (%*)))
-                (sFromInteger (sing :: Sing 2))))
-            ((applySing ((singFun1 @FromEnumSym0) sFromEnum)) sAs)
+        = applySing
+            (applySing
+               (singFun2 @(*@#@$) (%*)) (sFromInteger (sing :: Sing 2)))
+            (applySing (singFun1 @FromEnumSym0 sFromEnum) sAs)
       sFromEnum (SCons STrue (sAs :: Sing as))
-        = (applySing
-             ((applySing ((singFun2 @(+@#@$)) (%+)))
-                (sFromInteger (sing :: Sing 1))))
-            ((applySing
-                ((applySing ((singFun2 @(*@#@$)) (%*)))
-                   (sFromInteger (sing :: Sing 2))))
-               ((applySing ((singFun1 @FromEnumSym0) sFromEnum)) sAs))
+        = applySing
+            (applySing
+               (singFun2 @(+@#@$) (%+)) (sFromInteger (sing :: Sing 1)))
+            (applySing
+               (applySing
+                  (singFun2 @(*@#@$) (%*)) (sFromInteger (sing :: Sing 2)))
+               (applySing (singFun1 @FromEnumSym0 sFromEnum) sAs))
diff --git a/tests/compile-and-dump/Singletons/T136b.golden b/tests/compile-and-dump/Singletons/T136b.golden
--- a/tests/compile-and-dump/Singletons/T136b.golden
+++ b/tests/compile-and-dump/Singletons/T136b.golden
@@ -10,18 +10,18 @@
       where
         MethSym0KindInference :: SameKind (Apply MethSym0 arg) (MethSym1 arg) =>
                                  MethSym0 a0123456789876543210
-    type instance Apply MethSym0 a0123456789876543210 = Meth a0123456789876543210
+    type instance Apply @a @a MethSym0 a0123456789876543210 = Meth a0123456789876543210
     instance SuppressUnusedWarnings MethSym0 where
-      suppressUnusedWarnings = snd (((,) MethSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MethSym0KindInference ())
     type MethSym1 :: forall a. a -> a
-    type family MethSym1 (a0123456789876543210 :: a) :: a where
+    type family MethSym1 @a (a0123456789876543210 :: a) :: a where
       MethSym1 a0123456789876543210 = Meth a0123456789876543210
     class PC a where
       type family Meth (arg :: a) :: a
     class SC a where
-      sMeth :: forall (t :: a). Sing t -> Sing (Apply MethSym0 t :: a)
+      sMeth :: (forall (t :: a). Sing t -> Sing (Meth t :: a) :: Type)
     instance SC a => SingI (MethSym0 :: (~>) a a) where
-      sing = (singFun1 @MethSym0) sMeth
+      sing = singFun1 @MethSym0 sMeth
 Singletons/T136b.hs:(0,0)-(0,0): Splicing declarations
     singletons
       [d| instance C Bool where
@@ -32,23 +32,8 @@
     type Meth_0123456789876543210 :: Bool -> Bool
     type family Meth_0123456789876543210 (a :: Bool) :: Bool where
       Meth_0123456789876543210 a_0123456789876543210 = Apply NotSym0 a_0123456789876543210
-    type Meth_0123456789876543210Sym0 :: (~>) Bool Bool
-    data Meth_0123456789876543210Sym0 :: (~>) Bool Bool
-      where
-        Meth_0123456789876543210Sym0KindInference :: SameKind (Apply Meth_0123456789876543210Sym0 arg) (Meth_0123456789876543210Sym1 arg) =>
-                                                     Meth_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Meth_0123456789876543210Sym0 a0123456789876543210 = Meth_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings Meth_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Meth_0123456789876543210Sym0KindInference) ())
-    type Meth_0123456789876543210Sym1 :: Bool -> Bool
-    type family Meth_0123456789876543210Sym1 (a0123456789876543210 :: Bool) :: Bool where
-      Meth_0123456789876543210Sym1 a0123456789876543210 = Meth_0123456789876543210 a0123456789876543210
     instance PC Bool where
-      type Meth a = Apply Meth_0123456789876543210Sym0 a
+      type Meth a = Meth_0123456789876543210 a
     instance SC Bool where
-      sMeth ::
-        forall (t :: Bool). Sing t
-                            -> Sing (Apply (MethSym0 :: TyFun Bool Bool -> Type) t)
       sMeth (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing ((singFun1 @NotSym0) sNot)) sA_0123456789876543210
+        = applySing (singFun1 @NotSym0 sNot) sA_0123456789876543210
diff --git a/tests/compile-and-dump/Singletons/T145.golden b/tests/compile-and-dump/Singletons/T145.golden
--- a/tests/compile-and-dump/Singletons/T145.golden
+++ b/tests/compile-and-dump/Singletons/T145.golden
@@ -10,32 +10,32 @@
       where
         ColSym0KindInference :: SameKind (Apply ColSym0 arg) (ColSym1 arg) =>
                                 ColSym0 a0123456789876543210
-    type instance Apply ColSym0 a0123456789876543210 = ColSym1 a0123456789876543210
+    type instance Apply @(f a) @((~>) a Bool) ColSym0 a0123456789876543210 = ColSym1 a0123456789876543210
     instance SuppressUnusedWarnings ColSym0 where
-      suppressUnusedWarnings = snd (((,) ColSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) ColSym0KindInference ())
     type ColSym1 :: forall f a. f a -> (~>) a Bool
     data ColSym1 (a0123456789876543210 :: f a) :: (~>) a Bool
       where
         ColSym1KindInference :: SameKind (Apply (ColSym1 a0123456789876543210) arg) (ColSym2 a0123456789876543210 arg) =>
                                 ColSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ColSym1 a0123456789876543210) a0123456789876543210 = Col a0123456789876543210 a0123456789876543210
+    type instance Apply @a @Bool (ColSym1 a0123456789876543210) a0123456789876543210 = Col a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (ColSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ColSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) ColSym1KindInference ())
     type ColSym2 :: forall f a. f a -> a -> Bool
-    type family ColSym2 (a0123456789876543210 :: f a) (a0123456789876543210 :: a) :: Bool where
+    type family ColSym2 @f @a (a0123456789876543210 :: f a) (a0123456789876543210 :: a) :: Bool where
       ColSym2 a0123456789876543210 a0123456789876543210 = Col a0123456789876543210 a0123456789876543210
     class PColumn (f :: Type -> Type) where
       type family Col (arg :: f a) (arg :: a) :: Bool
     class SColumn (f :: Type -> Type) where
       sCol ::
-        forall a (t :: f a) (t :: a). Sing t
-                                      -> Sing t -> Sing (Apply (Apply ColSym0 t) t :: Bool)
+        (forall (t :: f a) (t :: a).
+         Sing t -> Sing t -> Sing (Col t t :: Bool) :: Type)
     instance SColumn f =>
              SingI (ColSym0 :: (~>) (f a) ((~>) a Bool)) where
-      sing = (singFun2 @ColSym0) sCol
+      sing = singFun2 @ColSym0 sCol
     instance (SColumn f, SingI d) =>
              SingI (ColSym1 (d :: f a) :: (~>) a Bool) where
-      sing = (singFun1 @(ColSym1 (d :: f a))) (sCol (sing @d))
+      sing = singFun1 @(ColSym1 (d :: f a)) (sCol (sing @d))
     instance SColumn f => SingI1 (ColSym1 :: f a -> (~>) a Bool) where
       liftSing (s :: Sing (d :: f a))
-        = (singFun1 @(ColSym1 (d :: f a))) (sCol s)
+        = singFun1 @(ColSym1 (d :: f a)) (sCol s)
diff --git a/tests/compile-and-dump/Singletons/T150.golden b/tests/compile-and-dump/Singletons/T150.golden
--- a/tests/compile-and-dump/Singletons/T150.golden
+++ b/tests/compile-and-dump/Singletons/T150.golden
@@ -59,7 +59,7 @@
     (!) VNil n = case n of {}
     mapVec :: (a -> b) -> Vec n a -> Vec n b
     mapVec _ VNil = VNil
-    mapVec f (VCons x xs) = (VCons (f x)) ((mapVec f) xs)
+    mapVec f (VCons x xs) = VCons (f x) (mapVec f xs)
     data Equal :: Type -> Type -> Type where Reflexive :: Equal a a
     symmetry :: Equal a b -> Equal b a
     symmetry Reflexive = Reflexive
@@ -71,18 +71,18 @@
         HCons :: x -> (HList xs) -> HList ('(:) x xs)
     data Obj :: Type where Obj :: a -> Obj
     type FZSym0 :: Fin ('Succ n)
-    type family FZSym0 :: Fin ('Succ n) where
+    type family FZSym0 @n :: Fin ('Succ n) where
       FZSym0 = FZ
     type FSSym0 :: (~>) (Fin n) (Fin ('Succ n))
     data FSSym0 :: (~>) (Fin n) (Fin ('Succ n))
       where
         FSSym0KindInference :: SameKind (Apply FSSym0 arg) (FSSym1 arg) =>
                                FSSym0 a0123456789876543210
-    type instance Apply FSSym0 a0123456789876543210 = FS a0123456789876543210
+    type instance Apply @(Fin n) @(Fin ('Succ n)) FSSym0 a0123456789876543210 = FS a0123456789876543210
     instance SuppressUnusedWarnings FSSym0 where
-      suppressUnusedWarnings = snd (((,) FSSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FSSym0KindInference ())
     type FSSym1 :: Fin n -> Fin ('Succ n)
-    type family FSSym1 (a0123456789876543210 :: Fin n) :: Fin ('Succ n) where
+    type family FSSym1 @n (a0123456789876543210 :: Fin n) :: Fin ('Succ n) where
       FSSym1 a0123456789876543210 = FS a0123456789876543210
     type MkFoo1Sym0 :: Foo Bool
     type family MkFoo1Sym0 :: Foo Bool where
@@ -91,29 +91,29 @@
     type family MkFoo2Sym0 :: Foo Ordering where
       MkFoo2Sym0 = MkFoo2
     type VNilSym0 :: Vec 'Zero a
-    type family VNilSym0 :: Vec 'Zero a where
+    type family VNilSym0 @a :: Vec 'Zero a where
       VNilSym0 = VNil
     type VConsSym0 :: (~>) a ((~>) (Vec n a) (Vec ('Succ n) a))
     data VConsSym0 :: (~>) a ((~>) (Vec n a) (Vec ('Succ n) a))
       where
         VConsSym0KindInference :: SameKind (Apply VConsSym0 arg) (VConsSym1 arg) =>
                                   VConsSym0 a0123456789876543210
-    type instance Apply VConsSym0 a0123456789876543210 = VConsSym1 a0123456789876543210
+    type instance Apply @a @((~>) (Vec n a) (Vec ('Succ n) a)) VConsSym0 a0123456789876543210 = VConsSym1 a0123456789876543210
     instance SuppressUnusedWarnings VConsSym0 where
-      suppressUnusedWarnings = snd (((,) VConsSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) VConsSym0KindInference ())
     type VConsSym1 :: a -> (~>) (Vec n a) (Vec ('Succ n) a)
     data VConsSym1 (a0123456789876543210 :: a) :: (~>) (Vec n a) (Vec ('Succ n) a)
       where
         VConsSym1KindInference :: SameKind (Apply (VConsSym1 a0123456789876543210) arg) (VConsSym2 a0123456789876543210 arg) =>
                                   VConsSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (VConsSym1 a0123456789876543210) a0123456789876543210 = VCons a0123456789876543210 a0123456789876543210
+    type instance Apply @(Vec n a) @(Vec ('Succ n) a) (VConsSym1 a0123456789876543210) a0123456789876543210 = VCons a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (VConsSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) VConsSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) VConsSym1KindInference ())
     type VConsSym2 :: a -> Vec n a -> Vec ('Succ n) a
-    type family VConsSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: Vec n a) :: Vec ('Succ n) a where
+    type family VConsSym2 @a @n (a0123456789876543210 :: a) (a0123456789876543210 :: Vec n a) :: Vec ('Succ n) a where
       VConsSym2 a0123456789876543210 a0123456789876543210 = VCons a0123456789876543210 a0123456789876543210
     type ReflexiveSym0 :: Equal a a
-    type family ReflexiveSym0 :: Equal a a where
+    type family ReflexiveSym0 @a :: Equal a a where
       ReflexiveSym0 = Reflexive
     type HNilSym0 :: HList '[]
     type family HNilSym0 :: HList '[] where
@@ -123,213 +123,220 @@
       where
         HConsSym0KindInference :: SameKind (Apply HConsSym0 arg) (HConsSym1 arg) =>
                                   HConsSym0 a0123456789876543210
-    type instance Apply HConsSym0 a0123456789876543210 = HConsSym1 a0123456789876543210
+    type instance Apply @x @((~>) (HList xs) (HList ('(:) x xs))) HConsSym0 a0123456789876543210 = HConsSym1 a0123456789876543210
     instance SuppressUnusedWarnings HConsSym0 where
-      suppressUnusedWarnings = snd (((,) HConsSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) HConsSym0KindInference ())
     type HConsSym1 :: x -> (~>) (HList xs) (HList ('(:) x xs))
     data HConsSym1 (a0123456789876543210 :: x) :: (~>) (HList xs) (HList ('(:) x xs))
       where
         HConsSym1KindInference :: SameKind (Apply (HConsSym1 a0123456789876543210) arg) (HConsSym2 a0123456789876543210 arg) =>
                                   HConsSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (HConsSym1 a0123456789876543210) a0123456789876543210 = HCons a0123456789876543210 a0123456789876543210
+    type instance Apply @(HList xs) @(HList ('(:) x xs)) (HConsSym1 a0123456789876543210) a0123456789876543210 = HCons a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (HConsSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) HConsSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) HConsSym1KindInference ())
     type HConsSym2 :: x -> HList xs -> HList ('(:) x xs)
-    type family HConsSym2 (a0123456789876543210 :: x) (a0123456789876543210 :: HList xs) :: HList ('(:) x xs) where
+    type family HConsSym2 @x @xs (a0123456789876543210 :: x) (a0123456789876543210 :: HList xs) :: HList ('(:) x xs) where
       HConsSym2 a0123456789876543210 a0123456789876543210 = HCons a0123456789876543210 a0123456789876543210
     type ObjSym0 :: (~>) a Obj
     data ObjSym0 :: (~>) a Obj
       where
         ObjSym0KindInference :: SameKind (Apply ObjSym0 arg) (ObjSym1 arg) =>
                                 ObjSym0 a0123456789876543210
-    type instance Apply ObjSym0 a0123456789876543210 = Obj a0123456789876543210
+    type instance Apply @a @Obj ObjSym0 a0123456789876543210 = Obj a0123456789876543210
     instance SuppressUnusedWarnings ObjSym0 where
-      suppressUnusedWarnings = snd (((,) ObjSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) ObjSym0KindInference ())
     type ObjSym1 :: a -> Obj
-    type family ObjSym1 (a0123456789876543210 :: a) :: Obj where
+    type family ObjSym1 @a (a0123456789876543210 :: a) :: Obj where
       ObjSym1 a0123456789876543210 = Obj a0123456789876543210
-    type family Case_0123456789876543210 n t where
+    type family LamCases_0123456789876543210 (n0123456789876543210 :: Fin n0123456789876543210) a_0123456789876543210 where
+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: Fin n0123456789876543210) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: Fin n0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
     type TransitivitySym0 :: (~>) (Equal a b) ((~>) (Equal b c) (Equal a c))
     data TransitivitySym0 :: (~>) (Equal a b) ((~>) (Equal b c) (Equal a c))
       where
         TransitivitySym0KindInference :: SameKind (Apply TransitivitySym0 arg) (TransitivitySym1 arg) =>
                                          TransitivitySym0 a0123456789876543210
-    type instance Apply TransitivitySym0 a0123456789876543210 = TransitivitySym1 a0123456789876543210
+    type instance Apply @(Equal a b) @((~>) (Equal b c) (Equal a c)) TransitivitySym0 a0123456789876543210 = TransitivitySym1 a0123456789876543210
     instance SuppressUnusedWarnings TransitivitySym0 where
-      suppressUnusedWarnings
-        = snd (((,) TransitivitySym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) TransitivitySym0KindInference ())
     type TransitivitySym1 :: Equal a b -> (~>) (Equal b c) (Equal a c)
     data TransitivitySym1 (a0123456789876543210 :: Equal a b) :: (~>) (Equal b c) (Equal a c)
       where
         TransitivitySym1KindInference :: SameKind (Apply (TransitivitySym1 a0123456789876543210) arg) (TransitivitySym2 a0123456789876543210 arg) =>
                                          TransitivitySym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TransitivitySym1 a0123456789876543210) a0123456789876543210 = Transitivity a0123456789876543210 a0123456789876543210
+    type instance Apply @(Equal b c) @(Equal a c) (TransitivitySym1 a0123456789876543210) a0123456789876543210 = Transitivity a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (TransitivitySym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TransitivitySym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) TransitivitySym1KindInference ())
     type TransitivitySym2 :: Equal a b -> Equal b c -> Equal a c
-    type family TransitivitySym2 (a0123456789876543210 :: Equal a b) (a0123456789876543210 :: Equal b c) :: Equal a c where
+    type family TransitivitySym2 @a @b @c (a0123456789876543210 :: Equal a b) (a0123456789876543210 :: Equal b c) :: Equal a c where
       TransitivitySym2 a0123456789876543210 a0123456789876543210 = Transitivity a0123456789876543210 a0123456789876543210
     type SymmetrySym0 :: (~>) (Equal a b) (Equal b a)
     data SymmetrySym0 :: (~>) (Equal a b) (Equal b a)
       where
         SymmetrySym0KindInference :: SameKind (Apply SymmetrySym0 arg) (SymmetrySym1 arg) =>
                                      SymmetrySym0 a0123456789876543210
-    type instance Apply SymmetrySym0 a0123456789876543210 = Symmetry a0123456789876543210
+    type instance Apply @(Equal a b) @(Equal b a) SymmetrySym0 a0123456789876543210 = Symmetry a0123456789876543210
     instance SuppressUnusedWarnings SymmetrySym0 where
-      suppressUnusedWarnings = snd (((,) SymmetrySym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SymmetrySym0KindInference ())
     type SymmetrySym1 :: Equal a b -> Equal b a
-    type family SymmetrySym1 (a0123456789876543210 :: Equal a b) :: Equal b a where
+    type family SymmetrySym1 @a @b (a0123456789876543210 :: Equal a b) :: Equal b a where
       SymmetrySym1 a0123456789876543210 = Symmetry a0123456789876543210
     type MapVecSym0 :: (~>) ((~>) a b) ((~>) (Vec n a) (Vec n b))
     data MapVecSym0 :: (~>) ((~>) a b) ((~>) (Vec n a) (Vec n b))
       where
         MapVecSym0KindInference :: SameKind (Apply MapVecSym0 arg) (MapVecSym1 arg) =>
                                    MapVecSym0 a0123456789876543210
-    type instance Apply MapVecSym0 a0123456789876543210 = MapVecSym1 a0123456789876543210
+    type instance Apply @((~>) a b) @((~>) (Vec n a) (Vec n b)) MapVecSym0 a0123456789876543210 = MapVecSym1 a0123456789876543210
     instance SuppressUnusedWarnings MapVecSym0 where
-      suppressUnusedWarnings = snd (((,) MapVecSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MapVecSym0KindInference ())
     type MapVecSym1 :: (~>) a b -> (~>) (Vec n a) (Vec n b)
     data MapVecSym1 (a0123456789876543210 :: (~>) a b) :: (~>) (Vec n a) (Vec n b)
       where
         MapVecSym1KindInference :: SameKind (Apply (MapVecSym1 a0123456789876543210) arg) (MapVecSym2 a0123456789876543210 arg) =>
                                    MapVecSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MapVecSym1 a0123456789876543210) a0123456789876543210 = MapVec a0123456789876543210 a0123456789876543210
+    type instance Apply @(Vec n a) @(Vec n b) (MapVecSym1 a0123456789876543210) a0123456789876543210 = MapVec a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MapVecSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MapVecSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) MapVecSym1KindInference ())
     type MapVecSym2 :: (~>) a b -> Vec n a -> Vec n b
-    type family MapVecSym2 (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: Vec n a) :: Vec n b where
+    type family MapVecSym2 @a @b @n (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: Vec n a) :: Vec n b where
       MapVecSym2 a0123456789876543210 a0123456789876543210 = MapVec a0123456789876543210 a0123456789876543210
     type (!@#@$) :: (~>) (Vec n a) ((~>) (Fin n) a)
     data (!@#@$) :: (~>) (Vec n a) ((~>) (Fin n) a)
       where
         (:!@#@$###) :: SameKind (Apply (!@#@$) arg) ((!@#@$$) arg) =>
                        (!@#@$) a0123456789876543210
-    type instance Apply (!@#@$) a0123456789876543210 = (!@#@$$) a0123456789876543210
+    type instance Apply @(Vec n a) @((~>) (Fin n) a) (!@#@$) a0123456789876543210 = (!@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (!@#@$) where
-      suppressUnusedWarnings = snd (((,) (:!@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (:!@#@$###) ())
     type (!@#@$$) :: Vec n a -> (~>) (Fin n) a
     data (!@#@$$) (a0123456789876543210 :: Vec n a) :: (~>) (Fin n) a
       where
         (:!@#@$$###) :: SameKind (Apply ((!@#@$$) a0123456789876543210) arg) ((!@#@$$$) a0123456789876543210 arg) =>
                         (!@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((!@#@$$) a0123456789876543210) a0123456789876543210 = (!) a0123456789876543210 a0123456789876543210
+    type instance Apply @(Fin n) @a ((!@#@$$) a0123456789876543210) a0123456789876543210 = (!) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((!@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:!@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (:!@#@$$###) ())
     type (!@#@$$$) :: Vec n a -> Fin n -> a
-    type family (!@#@$$$) (a0123456789876543210 :: Vec n a) (a0123456789876543210 :: Fin n) :: a where
+    type family (!@#@$$$) @n @a (a0123456789876543210 :: Vec n a) (a0123456789876543210 :: Fin n) :: a where
       (!@#@$$$) a0123456789876543210 a0123456789876543210 = (!) a0123456789876543210 a0123456789876543210
     type TailVecSym0 :: (~>) (Vec ('Succ n) a) (Vec n a)
     data TailVecSym0 :: (~>) (Vec ('Succ n) a) (Vec n a)
       where
         TailVecSym0KindInference :: SameKind (Apply TailVecSym0 arg) (TailVecSym1 arg) =>
                                     TailVecSym0 a0123456789876543210
-    type instance Apply TailVecSym0 a0123456789876543210 = TailVec a0123456789876543210
+    type instance Apply @(Vec ('Succ n) a) @(Vec n a) TailVecSym0 a0123456789876543210 = TailVec a0123456789876543210
     instance SuppressUnusedWarnings TailVecSym0 where
-      suppressUnusedWarnings = snd (((,) TailVecSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) TailVecSym0KindInference ())
     type TailVecSym1 :: Vec ('Succ n) a -> Vec n a
-    type family TailVecSym1 (a0123456789876543210 :: Vec ('Succ n) a) :: Vec n a where
+    type family TailVecSym1 @n @a (a0123456789876543210 :: Vec ('Succ n) a) :: Vec n a where
       TailVecSym1 a0123456789876543210 = TailVec a0123456789876543210
     type HeadVecSym0 :: (~>) (Vec ('Succ n) a) a
     data HeadVecSym0 :: (~>) (Vec ('Succ n) a) a
       where
         HeadVecSym0KindInference :: SameKind (Apply HeadVecSym0 arg) (HeadVecSym1 arg) =>
                                     HeadVecSym0 a0123456789876543210
-    type instance Apply HeadVecSym0 a0123456789876543210 = HeadVec a0123456789876543210
+    type instance Apply @(Vec ('Succ n) a) @a HeadVecSym0 a0123456789876543210 = HeadVec a0123456789876543210
     instance SuppressUnusedWarnings HeadVecSym0 where
-      suppressUnusedWarnings = snd (((,) HeadVecSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) HeadVecSym0KindInference ())
     type HeadVecSym1 :: Vec ('Succ n) a -> a
-    type family HeadVecSym1 (a0123456789876543210 :: Vec ('Succ n) a) :: a where
+    type family HeadVecSym1 @n @a (a0123456789876543210 :: Vec ('Succ n) a) :: a where
       HeadVecSym1 a0123456789876543210 = HeadVec a0123456789876543210
     type Transitivity :: Equal a b -> Equal b c -> Equal a c
-    type family Transitivity (a :: Equal a b) (a :: Equal b c) :: Equal a c where
+    type family Transitivity @a @b @c (a :: Equal a b) (a :: Equal b c) :: Equal a c where
       Transitivity Reflexive Reflexive = ReflexiveSym0
     type Symmetry :: Equal a b -> Equal b a
-    type family Symmetry (a :: Equal a b) :: Equal b a where
+    type family Symmetry @a @b (a :: Equal a b) :: Equal b a where
       Symmetry Reflexive = ReflexiveSym0
     type MapVec :: (~>) a b -> Vec n a -> Vec n b
-    type family MapVec (a :: (~>) a b) (a :: Vec n a) :: Vec n b where
+    type family MapVec @a @b @n (a :: (~>) a b) (a :: Vec n a) :: Vec n b where
       MapVec _ VNil = VNilSym0
       MapVec f (VCons x xs) = Apply (Apply VConsSym0 (Apply f x)) (Apply (Apply MapVecSym0 f) xs)
     type (!) :: Vec n a -> Fin n -> a
-    type family (!) (a :: Vec n a) (a :: Fin n) :: a where
+    type family (!) @n @a (a :: Vec n a) (a :: Fin n) :: a where
       (!) (VCons x _) FZ = x
       (!) (VCons _ xs) (FS n) = Apply (Apply (!@#@$) xs) n
-      (!) VNil n = Case_0123456789876543210 n n
+      (!) VNil n = Apply (LamCases_0123456789876543210Sym0 n) n
     type TailVec :: Vec ('Succ n) a -> Vec n a
-    type family TailVec (a :: Vec ('Succ n) a) :: Vec n a where
+    type family TailVec @n @a (a :: Vec ('Succ n) a) :: Vec n a where
       TailVec (VCons _ xs) = xs
     type HeadVec :: Vec ('Succ n) a -> a
-    type family HeadVec (a :: Vec ('Succ n) a) :: a where
+    type family HeadVec @n @a (a :: Vec ('Succ n) a) :: a where
       HeadVec (VCons x _) = x
     sTransitivity ::
-      forall a b c (t :: Equal a b) (t :: Equal b c). Sing t
-                                                      -> Sing t
-                                                         -> Sing (Apply (Apply TransitivitySym0 t) t :: Equal a c)
+      (forall (t :: Equal a b) (t :: Equal b c).
+       Sing t -> Sing t -> Sing (Transitivity t t :: Equal a c) :: Type)
     sSymmetry ::
-      forall a b (t :: Equal a b). Sing t
-                                   -> Sing (Apply SymmetrySym0 t :: Equal b a)
+      (forall (t :: Equal a b).
+       Sing t -> Sing (Symmetry t :: Equal b a) :: Type)
     sMapVec ::
-      forall a b n (t :: (~>) a b) (t :: Vec n a). Sing t
-                                                   -> Sing t
-                                                      -> Sing (Apply (Apply MapVecSym0 t) t :: Vec n b)
+      (forall (t :: (~>) a b) (t :: Vec n a).
+       Sing t -> Sing t -> Sing (MapVec t t :: Vec n b) :: Type)
     (%!) ::
-      forall n a (t :: Vec n a) (t :: Fin n). Sing t
-                                              -> Sing t -> Sing (Apply (Apply (!@#@$) t) t :: a)
+      (forall (t :: Vec n a) (t :: Fin n).
+       Sing t -> Sing t -> Sing ((!) t t :: a) :: Type)
     sTailVec ::
-      forall n a (t :: Vec ('Succ n) a). Sing t
-                                         -> Sing (Apply TailVecSym0 t :: Vec n a)
+      (forall (t :: Vec ('Succ n) a).
+       Sing t -> Sing (TailVec t :: Vec n a) :: Type)
     sHeadVec ::
-      forall n a (t :: Vec ('Succ n) a). Sing t
-                                         -> Sing (Apply HeadVecSym0 t :: a)
+      (forall (t :: Vec ('Succ n) a).
+       Sing t -> Sing (HeadVec t :: a) :: Type)
     sTransitivity SReflexive SReflexive = SReflexive
     sSymmetry SReflexive = SReflexive
     sMapVec _ SVNil = SVNil
     sMapVec (sF :: Sing f) (SVCons (sX :: Sing x) (sXs :: Sing xs))
-      = (applySing
-           ((applySing ((singFun2 @VConsSym0) SVCons)) ((applySing sF) sX)))
-          ((applySing ((applySing ((singFun2 @MapVecSym0) sMapVec)) sF)) sXs)
+      = applySing
+          (applySing (singFun2 @VConsSym0 SVCons) (applySing sF sX))
+          (applySing (applySing (singFun2 @MapVecSym0 sMapVec) sF) sXs)
     (%!) (SVCons (sX :: Sing x) _) SFZ = sX
     (%!) (SVCons _ (sXs :: Sing xs)) (SFS (sN :: Sing n))
-      = (applySing ((applySing ((singFun2 @(!@#@$)) (%!))) sXs)) sN
+      = applySing (applySing (singFun2 @(!@#@$) (%!)) sXs) sN
     (%!) SVNil (sN :: Sing n)
-      = (id @(Sing (Case_0123456789876543210 n n :: a))) (case sN of {})
+      = applySing
+          (singFun1 @(LamCases_0123456789876543210Sym0 n) (\case)) sN
     sTailVec (SVCons _ (sXs :: Sing xs)) = sXs
     sHeadVec (SVCons (sX :: Sing x) _) = sX
     instance SingI (TransitivitySym0 :: (~>) (Equal a b) ((~>) (Equal b c) (Equal a c))) where
-      sing = (singFun2 @TransitivitySym0) sTransitivity
+      sing = singFun2 @TransitivitySym0 sTransitivity
     instance SingI d =>
              SingI (TransitivitySym1 (d :: Equal a b) :: (~>) (Equal b c) (Equal a c)) where
       sing
-        = (singFun1 @(TransitivitySym1 (d :: Equal a b)))
-            (sTransitivity (sing @d))
+        = singFun1
+            @(TransitivitySym1 (d :: Equal a b)) (sTransitivity (sing @d))
     instance SingI1 (TransitivitySym1 :: Equal a b
                                          -> (~>) (Equal b c) (Equal a c)) where
       liftSing (s :: Sing (d :: Equal a b))
-        = (singFun1 @(TransitivitySym1 (d :: Equal a b))) (sTransitivity s)
+        = singFun1 @(TransitivitySym1 (d :: Equal a b)) (sTransitivity s)
     instance SingI (SymmetrySym0 :: (~>) (Equal a b) (Equal b a)) where
-      sing = (singFun1 @SymmetrySym0) sSymmetry
+      sing = singFun1 @SymmetrySym0 sSymmetry
     instance SingI (MapVecSym0 :: (~>) ((~>) a b) ((~>) (Vec n a) (Vec n b))) where
-      sing = (singFun2 @MapVecSym0) sMapVec
+      sing = singFun2 @MapVecSym0 sMapVec
     instance SingI d =>
              SingI (MapVecSym1 (d :: (~>) a b) :: (~>) (Vec n a) (Vec n b)) where
-      sing = (singFun1 @(MapVecSym1 (d :: (~>) a b))) (sMapVec (sing @d))
+      sing = singFun1 @(MapVecSym1 (d :: (~>) a b)) (sMapVec (sing @d))
     instance SingI1 (MapVecSym1 :: (~>) a b
                                    -> (~>) (Vec n a) (Vec n b)) where
       liftSing (s :: Sing (d :: (~>) a b))
-        = (singFun1 @(MapVecSym1 (d :: (~>) a b))) (sMapVec s)
+        = singFun1 @(MapVecSym1 (d :: (~>) a b)) (sMapVec s)
     instance SingI ((!@#@$) :: (~>) (Vec n a) ((~>) (Fin n) a)) where
-      sing = (singFun2 @(!@#@$)) (%!)
+      sing = singFun2 @(!@#@$) (%!)
     instance SingI d =>
              SingI ((!@#@$$) (d :: Vec n a) :: (~>) (Fin n) a) where
-      sing = (singFun1 @((!@#@$$) (d :: Vec n a))) ((%!) (sing @d))
+      sing = singFun1 @((!@#@$$) (d :: Vec n a)) ((%!) (sing @d))
     instance SingI1 ((!@#@$$) :: Vec n a -> (~>) (Fin n) a) where
       liftSing (s :: Sing (d :: Vec n a))
-        = (singFun1 @((!@#@$$) (d :: Vec n a))) ((%!) s)
+        = singFun1 @((!@#@$$) (d :: Vec n a)) ((%!) s)
     instance SingI (TailVecSym0 :: (~>) (Vec ('Succ n) a) (Vec n a)) where
-      sing = (singFun1 @TailVecSym0) sTailVec
+      sing = singFun1 @TailVecSym0 sTailVec
     instance SingI (HeadVecSym0 :: (~>) (Vec ('Succ n) a) a) where
-      sing = (singFun1 @HeadVecSym0) sHeadVec
+      sing = singFun1 @HeadVecSym0 sHeadVec
     data SFin :: forall (a :: Nat). Fin a -> Type
       where
         SFZ :: forall n. SFin (FZ :: Fin ('Succ n))
@@ -366,7 +373,7 @@
     instance SingI1 FS where
       liftSing = SFS
     instance SingI (FSSym0 :: (~>) (Fin n) (Fin ('Succ n))) where
-      sing = (singFun1 @FSSym0) SFS
+      sing = singFun1 @FSSym0 SFS
     instance SingI MkFoo1 where
       sing = SMkFoo1
     instance SingI MkFoo2 where
@@ -375,43 +382,43 @@
       sing = SVNil
     instance (SingI n, SingI n) =>
              SingI (VCons (n :: a) (n :: Vec n a)) where
-      sing = (SVCons sing) sing
+      sing = SVCons sing sing
     instance SingI n => SingI1 (VCons (n :: a)) where
       liftSing = SVCons sing
     instance SingI2 VCons where
       liftSing2 = SVCons
     instance SingI (VConsSym0 :: (~>) a ((~>) (Vec n a) (Vec ('Succ n) a))) where
-      sing = (singFun2 @VConsSym0) SVCons
+      sing = singFun2 @VConsSym0 SVCons
     instance SingI d =>
              SingI (VConsSym1 (d :: a) :: (~>) (Vec n a) (Vec ('Succ n) a)) where
-      sing = (singFun1 @(VConsSym1 (d :: a))) (SVCons (sing @d))
+      sing = singFun1 @(VConsSym1 (d :: a)) (SVCons (sing @d))
     instance SingI1 (VConsSym1 :: a
                                   -> (~>) (Vec n a) (Vec ('Succ n) a)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(VConsSym1 (d :: a))) (SVCons s)
+        = singFun1 @(VConsSym1 (d :: a)) (SVCons s)
     instance SingI Reflexive where
       sing = SReflexive
     instance SingI HNil where
       sing = SHNil
     instance (SingI n, SingI n) =>
              SingI (HCons (n :: x) (n :: HList xs)) where
-      sing = (SHCons sing) sing
+      sing = SHCons sing sing
     instance SingI n => SingI1 (HCons (n :: x)) where
       liftSing = SHCons sing
     instance SingI2 HCons where
       liftSing2 = SHCons
     instance SingI (HConsSym0 :: (~>) x ((~>) (HList xs) (HList ('(:) x xs)))) where
-      sing = (singFun2 @HConsSym0) SHCons
+      sing = singFun2 @HConsSym0 SHCons
     instance SingI d =>
              SingI (HConsSym1 (d :: x) :: (~>) (HList xs) (HList ('(:) x xs))) where
-      sing = (singFun1 @(HConsSym1 (d :: x))) (SHCons (sing @d))
+      sing = singFun1 @(HConsSym1 (d :: x)) (SHCons (sing @d))
     instance SingI1 (HConsSym1 :: x
                                   -> (~>) (HList xs) (HList ('(:) x xs))) where
       liftSing (s :: Sing (d :: x))
-        = (singFun1 @(HConsSym1 (d :: x))) (SHCons s)
+        = singFun1 @(HConsSym1 (d :: x)) (SHCons s)
     instance SingI n => SingI (Obj (n :: a)) where
       sing = SObj sing
     instance SingI1 Obj where
       liftSing = SObj
     instance SingI (ObjSym0 :: (~>) a Obj) where
-      sing = (singFun1 @ObjSym0) SObj
+      sing = singFun1 @ObjSym0 SObj
diff --git a/tests/compile-and-dump/Singletons/T159.golden b/tests/compile-and-dump/Singletons/T159.golden
--- a/tests/compile-and-dump/Singletons/T159.golden
+++ b/tests/compile-and-dump/Singletons/T159.golden
@@ -63,45 +63,45 @@
       where
         C1Sym0KindInference :: SameKind (Apply C1Sym0 arg) (C1Sym1 arg) =>
                                C1Sym0 a0123456789876543210
-    type instance Apply C1Sym0 a0123456789876543210 = C1Sym1 a0123456789876543210
+    type instance Apply @T0 @((~>) T1 T1) C1Sym0 a0123456789876543210 = C1Sym1 a0123456789876543210
     instance SuppressUnusedWarnings C1Sym0 where
-      suppressUnusedWarnings = snd (((,) C1Sym0KindInference) ())
-    infixr 5 `C1Sym0`
+      suppressUnusedWarnings = snd ((,) C1Sym0KindInference ())
+    infixr 5 type `C1Sym0`
     type C1Sym1 :: T0 -> (~>) T1 T1
     data C1Sym1 (a0123456789876543210 :: T0) :: (~>) T1 T1
       where
         C1Sym1KindInference :: SameKind (Apply (C1Sym1 a0123456789876543210) arg) (C1Sym2 a0123456789876543210 arg) =>
                                C1Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (C1Sym1 a0123456789876543210) a0123456789876543210 = 'C1 a0123456789876543210 a0123456789876543210
+    type instance Apply @T1 @T1 (C1Sym1 a0123456789876543210) a0123456789876543210 = 'C1 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (C1Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) C1Sym1KindInference) ())
-    infixr 5 `C1Sym1`
+      suppressUnusedWarnings = snd ((,) C1Sym1KindInference ())
+    infixr 5 type `C1Sym1`
     type C1Sym2 :: T0 -> T1 -> T1
     type family C1Sym2 (a0123456789876543210 :: T0) (a0123456789876543210 :: T1) :: T1 where
       C1Sym2 a0123456789876543210 a0123456789876543210 = 'C1 a0123456789876543210 a0123456789876543210
-    infixr 5 `C1Sym2`
+    infixr 5 type `C1Sym2`
     type (:&&@#@$) :: (~>) T0 ((~>) T1 T1)
     data (:&&@#@$) :: (~>) T0 ((~>) T1 T1)
       where
         (::&&@#@$###) :: SameKind (Apply (:&&@#@$) arg) ((:&&@#@$$) arg) =>
                          (:&&@#@$) a0123456789876543210
-    type instance Apply (:&&@#@$) a0123456789876543210 = (:&&@#@$$) a0123456789876543210
+    type instance Apply @T0 @((~>) T1 T1) (:&&@#@$) a0123456789876543210 = (:&&@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:&&@#@$) where
-      suppressUnusedWarnings = snd (((,) (::&&@#@$###)) ())
-    infixr 5 :&&@#@$
+      suppressUnusedWarnings = snd ((,) (::&&@#@$###) ())
+    infixr 5 type :&&@#@$
     type (:&&@#@$$) :: T0 -> (~>) T1 T1
     data (:&&@#@$$) (a0123456789876543210 :: T0) :: (~>) T1 T1
       where
         (::&&@#@$$###) :: SameKind (Apply ((:&&@#@$$) a0123456789876543210) arg) ((:&&@#@$$$) a0123456789876543210 arg) =>
                           (:&&@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:&&@#@$$) a0123456789876543210) a0123456789876543210 = '(:&&) a0123456789876543210 a0123456789876543210
+    type instance Apply @T1 @T1 ((:&&@#@$$) a0123456789876543210) a0123456789876543210 = '(:&&) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:&&@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::&&@#@$$###)) ())
-    infixr 5 :&&@#@$$
+      suppressUnusedWarnings = snd ((,) (::&&@#@$$###) ())
+    infixr 5 type :&&@#@$$
     type (:&&@#@$$$) :: T0 -> T1 -> T1
     type family (:&&@#@$$$) (a0123456789876543210 :: T0) (a0123456789876543210 :: T1) :: T1 where
       (:&&@#@$$$) a0123456789876543210 a0123456789876543210 = '(:&&) a0123456789876543210 a0123456789876543210
-    infixr 5 :&&@#@$$$
+    infixr 5 type :&&@#@$$$
     type ST1 :: T1 -> Type
     data ST1 :: T1 -> Type
       where
@@ -114,48 +114,48 @@
     instance SingKind T1 where
       type Demote T1 = T1
       fromSing SN1 = N1
-      fromSing (SC1 b b) = (C1 (fromSing b)) (fromSing b)
-      fromSing ((:%&&) b b) = ((:&&) (fromSing b)) (fromSing b)
+      fromSing (SC1 b b) = C1 (fromSing b) (fromSing b)
+      fromSing ((:%&&) b b) = (:&&) (fromSing b) (fromSing b)
       toSing N1 = SomeSing SN1
       toSing (C1 (b :: Demote T0) (b :: Demote T1))
-        = case ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T1) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SC1 c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SC1 c c))
+            (toSing b :: SomeSing T0) (toSing b :: SomeSing T1)
       toSing ((:&&) (b :: Demote T0) (b :: Demote T1))
-        = case ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T1) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%&&) c) c)
-    infixr 5 `SC1`
-    infixr 5 :%&&
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:%&&) c c))
+            (toSing b :: SomeSing T0) (toSing b :: SomeSing T1)
+    infixr 5 data `SC1`
+    infixr 5 data :%&&
     instance SingI 'N1 where
       sing = SN1
     instance (SingI n, SingI n) =>
              SingI ('C1 (n :: T0) (n :: T1)) where
-      sing = (SC1 sing) sing
+      sing = SC1 sing sing
     instance SingI n => SingI1 ('C1 (n :: T0)) where
       liftSing = SC1 sing
     instance SingI2 'C1 where
       liftSing2 = SC1
     instance SingI (C1Sym0 :: (~>) T0 ((~>) T1 T1)) where
-      sing = (singFun2 @C1Sym0) SC1
+      sing = singFun2 @C1Sym0 SC1
     instance SingI d => SingI (C1Sym1 (d :: T0) :: (~>) T1 T1) where
-      sing = (singFun1 @(C1Sym1 (d :: T0))) (SC1 (sing @d))
+      sing = singFun1 @(C1Sym1 (d :: T0)) (SC1 (sing @d))
     instance SingI1 (C1Sym1 :: T0 -> (~>) T1 T1) where
       liftSing (s :: Sing (d :: T0))
-        = (singFun1 @(C1Sym1 (d :: T0))) (SC1 s)
+        = singFun1 @(C1Sym1 (d :: T0)) (SC1 s)
     instance (SingI n, SingI n) =>
              SingI ('(:&&) (n :: T0) (n :: T1)) where
-      sing = ((:%&&) sing) sing
+      sing = (:%&&) sing sing
     instance SingI n => SingI1 ('(:&&) (n :: T0)) where
       liftSing = (:%&&) sing
     instance SingI2 '(:&&) where
       liftSing2 = (:%&&)
     instance SingI ((:&&@#@$) :: (~>) T0 ((~>) T1 T1)) where
-      sing = (singFun2 @(:&&@#@$)) (:%&&)
+      sing = singFun2 @(:&&@#@$) (:%&&)
     instance SingI d =>
              SingI ((:&&@#@$$) (d :: T0) :: (~>) T1 T1) where
-      sing = (singFun1 @((:&&@#@$$) (d :: T0))) ((:%&&) (sing @d))
+      sing = singFun1 @((:&&@#@$$) (d :: T0)) ((:%&&) (sing @d))
     instance SingI1 ((:&&@#@$$) :: T0 -> (~>) T1 T1) where
       liftSing (s :: Sing (d :: T0))
-        = (singFun1 @((:&&@#@$$) (d :: T0))) ((:%&&) s)
+        = singFun1 @((:&&@#@$$) (d :: T0)) ((:%&&) s)
 Singletons/T159.hs:(0,0)-(0,0): Splicing declarations
     singletons
       [d| infixr 5 :||
@@ -174,47 +174,47 @@
       where
         C2Sym0KindInference :: SameKind (Apply C2Sym0 arg) (C2Sym1 arg) =>
                                C2Sym0 a0123456789876543210
-    type instance Apply C2Sym0 a0123456789876543210 = C2Sym1 a0123456789876543210
+    type instance Apply @T0 @((~>) T2 T2) C2Sym0 a0123456789876543210 = C2Sym1 a0123456789876543210
     instance SuppressUnusedWarnings C2Sym0 where
-      suppressUnusedWarnings = snd (((,) C2Sym0KindInference) ())
-    infixr 5 `C2Sym0`
+      suppressUnusedWarnings = snd ((,) C2Sym0KindInference ())
+    infixr 5 type `C2Sym0`
     type C2Sym1 :: T0 -> (~>) T2 T2
     data C2Sym1 (a0123456789876543210 :: T0) :: (~>) T2 T2
       where
         C2Sym1KindInference :: SameKind (Apply (C2Sym1 a0123456789876543210) arg) (C2Sym2 a0123456789876543210 arg) =>
                                C2Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (C2Sym1 a0123456789876543210) a0123456789876543210 = C2 a0123456789876543210 a0123456789876543210
+    type instance Apply @T2 @T2 (C2Sym1 a0123456789876543210) a0123456789876543210 = C2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (C2Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) C2Sym1KindInference) ())
-    infixr 5 `C2Sym1`
+      suppressUnusedWarnings = snd ((,) C2Sym1KindInference ())
+    infixr 5 type `C2Sym1`
     type C2Sym2 :: T0 -> T2 -> T2
     type family C2Sym2 (a0123456789876543210 :: T0) (a0123456789876543210 :: T2) :: T2 where
       C2Sym2 a0123456789876543210 a0123456789876543210 = C2 a0123456789876543210 a0123456789876543210
-    infixr 5 `C2Sym2`
+    infixr 5 type `C2Sym2`
     type (:||@#@$) :: (~>) T0 ((~>) T2 T2)
     data (:||@#@$) :: (~>) T0 ((~>) T2 T2)
       where
         (::||@#@$###) :: SameKind (Apply (:||@#@$) arg) ((:||@#@$$) arg) =>
                          (:||@#@$) a0123456789876543210
-    type instance Apply (:||@#@$) a0123456789876543210 = (:||@#@$$) a0123456789876543210
+    type instance Apply @T0 @((~>) T2 T2) (:||@#@$) a0123456789876543210 = (:||@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:||@#@$) where
-      suppressUnusedWarnings = snd (((,) (::||@#@$###)) ())
-    infixr 5 :||@#@$
+      suppressUnusedWarnings = snd ((,) (::||@#@$###) ())
+    infixr 5 type :||@#@$
     type (:||@#@$$) :: T0 -> (~>) T2 T2
     data (:||@#@$$) (a0123456789876543210 :: T0) :: (~>) T2 T2
       where
         (::||@#@$$###) :: SameKind (Apply ((:||@#@$$) a0123456789876543210) arg) ((:||@#@$$$) a0123456789876543210 arg) =>
                           (:||@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:||@#@$$) a0123456789876543210) a0123456789876543210 = (:||) a0123456789876543210 a0123456789876543210
+    type instance Apply @T2 @T2 ((:||@#@$$) a0123456789876543210) a0123456789876543210 = (:||) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:||@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::||@#@$$###)) ())
-    infixr 5 :||@#@$$
+      suppressUnusedWarnings = snd ((,) (::||@#@$$###) ())
+    infixr 5 type :||@#@$$
     type (:||@#@$$$) :: T0 -> T2 -> T2
     type family (:||@#@$$$) (a0123456789876543210 :: T0) (a0123456789876543210 :: T2) :: T2 where
       (:||@#@$$$) a0123456789876543210 a0123456789876543210 = (:||) a0123456789876543210 a0123456789876543210
-    infixr 5 :||@#@$$$
-    infixr 5 :%||
-    infixr 5 `SC2`
+    infixr 5 type :||@#@$$$
+    infixr 5 data :%||
+    infixr 5 data `SC2`
     data ST2 :: T2 -> Type
       where
         SN2 :: ST2 (N2 :: T2)
@@ -226,42 +226,42 @@
     instance SingKind T2 where
       type Demote T2 = T2
       fromSing SN2 = N2
-      fromSing (SC2 b b) = (C2 (fromSing b)) (fromSing b)
-      fromSing ((:%||) b b) = ((:||) (fromSing b)) (fromSing b)
+      fromSing (SC2 b b) = C2 (fromSing b) (fromSing b)
+      fromSing ((:%||) b b) = (:||) (fromSing b) (fromSing b)
       toSing N2 = SomeSing SN2
       toSing (C2 (b :: Demote T0) (b :: Demote T2))
-        = case ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T2) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SC2 c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SC2 c c))
+            (toSing b :: SomeSing T0) (toSing b :: SomeSing T2)
       toSing ((:||) (b :: Demote T0) (b :: Demote T2))
-        = case ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T2) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%||) c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:%||) c c))
+            (toSing b :: SomeSing T0) (toSing b :: SomeSing T2)
     instance SingI N2 where
       sing = SN2
     instance (SingI n, SingI n) => SingI (C2 (n :: T0) (n :: T2)) where
-      sing = (SC2 sing) sing
+      sing = SC2 sing sing
     instance SingI n => SingI1 (C2 (n :: T0)) where
       liftSing = SC2 sing
     instance SingI2 C2 where
       liftSing2 = SC2
     instance SingI (C2Sym0 :: (~>) T0 ((~>) T2 T2)) where
-      sing = (singFun2 @C2Sym0) SC2
+      sing = singFun2 @C2Sym0 SC2
     instance SingI d => SingI (C2Sym1 (d :: T0) :: (~>) T2 T2) where
-      sing = (singFun1 @(C2Sym1 (d :: T0))) (SC2 (sing @d))
+      sing = singFun1 @(C2Sym1 (d :: T0)) (SC2 (sing @d))
     instance SingI1 (C2Sym1 :: T0 -> (~>) T2 T2) where
       liftSing (s :: Sing (d :: T0))
-        = (singFun1 @(C2Sym1 (d :: T0))) (SC2 s)
+        = singFun1 @(C2Sym1 (d :: T0)) (SC2 s)
     instance (SingI n, SingI n) =>
              SingI ((:||) (n :: T0) (n :: T2)) where
-      sing = ((:%||) sing) sing
+      sing = (:%||) sing sing
     instance SingI n => SingI1 ((:||) (n :: T0)) where
       liftSing = (:%||) sing
     instance SingI2 (:||) where
       liftSing2 = (:%||)
     instance SingI ((:||@#@$) :: (~>) T0 ((~>) T2 T2)) where
-      sing = (singFun2 @(:||@#@$)) (:%||)
+      sing = singFun2 @(:||@#@$) (:%||)
     instance SingI d =>
              SingI ((:||@#@$$) (d :: T0) :: (~>) T2 T2) where
-      sing = (singFun1 @((:||@#@$$) (d :: T0))) ((:%||) (sing @d))
+      sing = singFun1 @((:||@#@$$) (d :: T0)) ((:%||) (sing @d))
     instance SingI1 ((:||@#@$$) :: T0 -> (~>) T2 T2) where
       liftSing (s :: Sing (d :: T0))
-        = (singFun1 @((:||@#@$$) (d :: T0))) ((:%||) s)
+        = singFun1 @((:||@#@$$) (d :: T0)) ((:%||) s)
diff --git a/tests/compile-and-dump/Singletons/T160.golden b/tests/compile-and-dump/Singletons/T160.golden
--- a/tests/compile-and-dump/Singletons/T160.golden
+++ b/tests/compile-and-dump/Singletons/T160.golden
@@ -5,65 +5,57 @@
   ======>
     foo :: (Num a, Eq a) => a -> a
     foo x = if (x == 0) then 1 else (typeError $ ShowType x)
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 x 'True = FromInteger 1
+      LamCases_0123456789876543210 x 'False = Apply (Apply ($@#@$) TypeErrorSym0) (Apply ShowTypeSym0 x)
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)
-               ())
-    type family Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 where
-      Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210
-    type family Let0123456789876543210Scrutinee_0123456789876543210 x where
-      Let0123456789876543210Scrutinee_0123456789876543210 x = Apply (Apply (==@#@$) x) (FromInteger 0)
-    type family Case_0123456789876543210 x t where
-      Case_0123456789876543210 x 'True = FromInteger 1
-      Case_0123456789876543210 x 'False = Apply (Apply ($@#@$) TypeErrorSym0) (Apply ShowTypeSym0 x)
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
     type FooSym0 :: (~>) a a
     data FooSym0 :: (~>) a a
       where
         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
                                 FooSym0 a0123456789876543210
-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210
+    type instance Apply @a @a FooSym0 a0123456789876543210 = Foo a0123456789876543210
     instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
     type FooSym1 :: a -> a
-    type family FooSym1 (a0123456789876543210 :: a) :: a where
+    type family FooSym1 @a (a0123456789876543210 :: a) :: a where
       FooSym1 a0123456789876543210 = Foo a0123456789876543210
     type Foo :: a -> a
-    type family Foo (a :: a) :: a where
-      Foo x = Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)
+    type family Foo @a (a :: a) :: a where
+      Foo x = Apply (LamCases_0123456789876543210Sym0 x) (Apply (Apply (==@#@$) x) (FromInteger 0))
     sFoo ::
-      forall a (t :: a). (SNum a, SEq a) =>
-                         Sing t -> Sing (Apply FooSym0 t :: a)
+      (forall (t :: a).
+       (SNum a, SEq a) => Sing t -> Sing (Foo t :: a) :: Type)
     sFoo (sX :: Sing x)
-      = let
-          sScrutinee_0123456789876543210 ::
-            Sing @_ (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)
-          sScrutinee_0123456789876543210
-            = (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sX))
-                (sFromInteger (sing :: Sing 0))
-        in
-          (id
-             @(Sing (Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x) :: a)))
-            (case sScrutinee_0123456789876543210 of
-               STrue -> sFromInteger (sing :: Sing 1)
-               SFalse
-                 -> (applySing
-                       ((applySing ((singFun2 @($@#@$)) (%$)))
-                          ((singFun1 @TypeErrorSym0) sTypeError)))
-                      ((applySing ((singFun1 @ShowTypeSym0) SShowType)) sX))
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 x)
+             (\cases
+                STrue -> sFromInteger (sing :: Sing 1)
+                SFalse
+                  -> applySing
+                       (applySing
+                          (singFun2 @($@#@$) (%$)) (singFun1 @TypeErrorSym0 sTypeError))
+                       (applySing (singFun1 @ShowTypeSym0 SShowType) sX)))
+          (applySing
+             (applySing (singFun2 @(==@#@$) (%==)) sX)
+             (sFromInteger (sing :: Sing 0)))
     instance (SNum a, SEq a) => SingI (FooSym0 :: (~>) a a) where
-      sing = (singFun1 @FooSym0) sFoo
-
-Singletons/T160.hs:0:0: error:
+      sing = singFun1 @FooSym0 sFoo
+Singletons/T160.hs:0:0: error: [GHC-64725]
     • 1
     • In the expression: Refl
       In an equation for ‘f’: f = Refl
    |
 13 | f = Refl
    |     ^^^^
+
diff --git a/tests/compile-and-dump/Singletons/T163.golden b/tests/compile-and-dump/Singletons/T163.golden
--- a/tests/compile-and-dump/Singletons/T163.golden
+++ b/tests/compile-and-dump/Singletons/T163.golden
@@ -7,22 +7,22 @@
       where
         LSym0KindInference :: SameKind (Apply LSym0 arg) (LSym1 arg) =>
                               LSym0 a0123456789876543210
-    type instance Apply LSym0 a0123456789876543210 = L a0123456789876543210
+    type instance Apply @a @((+) a b) LSym0 a0123456789876543210 = L a0123456789876543210
     instance SuppressUnusedWarnings LSym0 where
-      suppressUnusedWarnings = snd (((,) LSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) LSym0KindInference ())
     type LSym1 :: forall a b. a -> (+) a b
-    type family LSym1 (a0123456789876543210 :: a) :: (+) a b where
+    type family LSym1 @a @b (a0123456789876543210 :: a) :: (+) a b where
       LSym1 a0123456789876543210 = L a0123456789876543210
     type RSym0 :: forall a b. (~>) b ((+) a b)
     data RSym0 :: (~>) b ((+) a b)
       where
         RSym0KindInference :: SameKind (Apply RSym0 arg) (RSym1 arg) =>
                               RSym0 a0123456789876543210
-    type instance Apply RSym0 a0123456789876543210 = R a0123456789876543210
+    type instance Apply @b @((+) a b) RSym0 a0123456789876543210 = R a0123456789876543210
     instance SuppressUnusedWarnings RSym0 where
-      suppressUnusedWarnings = snd (((,) RSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) RSym0KindInference ())
     type RSym1 :: forall a b. b -> (+) a b
-    type family RSym1 (a0123456789876543210 :: b) :: (+) a b where
+    type family RSym1 @a @b (a0123456789876543210 :: b) :: (+) a b where
       RSym1 a0123456789876543210 = R a0123456789876543210
     data (%+) :: forall a b. (+) a b -> Type
       where
@@ -34,18 +34,18 @@
       fromSing (SL b) = L (fromSing b)
       fromSing (SR b) = R (fromSing b)
       toSing (L (b :: Demote a))
-        = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SL c)
+        = (\cases (SomeSing c) -> SomeSing (SL c)) (toSing b :: SomeSing a)
       toSing (R (b :: Demote b))
-        = case toSing b :: SomeSing b of SomeSing c -> SomeSing (SR c)
+        = (\cases (SomeSing c) -> SomeSing (SR c)) (toSing b :: SomeSing b)
     instance SingI n => SingI (L (n :: a)) where
       sing = SL sing
     instance SingI1 L where
       liftSing = SL
     instance SingI (LSym0 :: (~>) a ((+) a b)) where
-      sing = (singFun1 @LSym0) SL
+      sing = singFun1 @LSym0 SL
     instance SingI n => SingI (R (n :: b)) where
       sing = SR sing
     instance SingI1 R where
       liftSing = SR
     instance SingI (RSym0 :: (~>) b ((+) a b)) where
-      sing = (singFun1 @RSym0) SR
+      sing = singFun1 @RSym0 SR
diff --git a/tests/compile-and-dump/Singletons/T166.golden b/tests/compile-and-dump/Singletons/T166.golden
--- a/tests/compile-and-dump/Singletons/T166.golden
+++ b/tests/compile-and-dump/Singletons/T166.golden
@@ -10,140 +10,119 @@
       where
         FoosPrecSym0KindInference :: SameKind (Apply FoosPrecSym0 arg) (FoosPrecSym1 arg) =>
                                      FoosPrecSym0 a0123456789876543210
-    type instance Apply FoosPrecSym0 a0123456789876543210 = FoosPrecSym1 a0123456789876543210
+    type instance Apply @Natural @((~>) a ((~>) [Bool] [Bool])) FoosPrecSym0 a0123456789876543210 = FoosPrecSym1 a0123456789876543210
     instance SuppressUnusedWarnings FoosPrecSym0 where
-      suppressUnusedWarnings = snd (((,) FoosPrecSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FoosPrecSym0KindInference ())
     type FoosPrecSym1 :: forall a. Natural
                                    -> (~>) a ((~>) [Bool] [Bool])
     data FoosPrecSym1 (a0123456789876543210 :: Natural) :: (~>) a ((~>) [Bool] [Bool])
       where
         FoosPrecSym1KindInference :: SameKind (Apply (FoosPrecSym1 a0123456789876543210) arg) (FoosPrecSym2 a0123456789876543210 arg) =>
                                      FoosPrecSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FoosPrecSym1 a0123456789876543210) a0123456789876543210 = FoosPrecSym2 a0123456789876543210 a0123456789876543210
+    type instance Apply @a @((~>) [Bool] [Bool]) (FoosPrecSym1 a0123456789876543210) a0123456789876543210 = FoosPrecSym2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (FoosPrecSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FoosPrecSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) FoosPrecSym1KindInference ())
     type FoosPrecSym2 :: forall a. Natural -> a -> (~>) [Bool] [Bool]
     data FoosPrecSym2 (a0123456789876543210 :: Natural) (a0123456789876543210 :: a) :: (~>) [Bool] [Bool]
       where
         FoosPrecSym2KindInference :: SameKind (Apply (FoosPrecSym2 a0123456789876543210 a0123456789876543210) arg) (FoosPrecSym3 a0123456789876543210 a0123456789876543210 arg) =>
                                      FoosPrecSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (FoosPrecSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = FoosPrec a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @[Bool] @[Bool] (FoosPrecSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = FoosPrec a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (FoosPrecSym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FoosPrecSym2KindInference) ())
+      suppressUnusedWarnings = snd ((,) FoosPrecSym2KindInference ())
     type FoosPrecSym3 :: forall a. Natural -> a -> [Bool] -> [Bool]
-    type family FoosPrecSym3 (a0123456789876543210 :: Natural) (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where
+    type family FoosPrecSym3 @a (a0123456789876543210 :: Natural) (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where
       FoosPrecSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = FoosPrec a0123456789876543210 a0123456789876543210 a0123456789876543210
     type FooSym0 :: forall a. (~>) a [Bool]
     data FooSym0 :: (~>) a [Bool]
       where
         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
                                 FooSym0 a0123456789876543210
-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210
+    type instance Apply @a @[Bool] FooSym0 a0123456789876543210 = Foo a0123456789876543210
     instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
     type FooSym1 :: forall a. a -> [Bool]
-    type family FooSym1 (a0123456789876543210 :: a) :: [Bool] where
+    type family FooSym1 @a (a0123456789876543210 :: a) :: [Bool] where
       FooSym1 a0123456789876543210 = Foo a0123456789876543210
-    type family Lambda_0123456789876543210 x s where
-      Lambda_0123456789876543210 x s = Apply (Apply (Apply FoosPrecSym0 (FromInteger 0)) x) s
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 s0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 s0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) s0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 s0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    type family Lambda_0123456789876543210Sym2 x0123456789876543210 s0123456789876543210 where
-      Lambda_0123456789876543210Sym2 x0123456789876543210 s0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 s0123456789876543210
-    type Foo_0123456789876543210 :: a -> [Bool]
-    type family Foo_0123456789876543210 (a :: a) :: [Bool] where
-      Foo_0123456789876543210 x = Apply Lambda_0123456789876543210Sym0 x
-    type Foo_0123456789876543210Sym0 :: (~>) a [Bool]
-    data Foo_0123456789876543210Sym0 :: (~>) a [Bool]
+    type family LamCases_0123456789876543210 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 a x s = Apply (Apply (Apply FoosPrecSym0 (FromInteger 0)) x) s
+    data LamCases_0123456789876543210Sym0 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Foo_0123456789876543210Sym0KindInference :: SameKind (Apply Foo_0123456789876543210Sym0 arg) (Foo_0123456789876543210Sym1 arg) =>
-                                                    Foo_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Foo_0123456789876543210Sym0 a0123456789876543210 = Foo_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings Foo_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Foo_0123456789876543210Sym0KindInference) ())
-    type Foo_0123456789876543210Sym1 :: a -> [Bool]
-    type family Foo_0123456789876543210Sym1 (a0123456789876543210 :: a) :: [Bool] where
-      Foo_0123456789876543210Sym1 a0123456789876543210 = Foo_0123456789876543210 a0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type Foo_0123456789876543210 :: forall a. a -> [Bool]
+    type family Foo_0123456789876543210 @a (a :: a) :: [Bool] where
+      Foo_0123456789876543210 @a (x :: a) = LamCases_0123456789876543210Sym0 a x
     class PFoo a where
       type family FoosPrec (arg :: Natural) (arg :: a) (arg :: [Bool]) :: [Bool]
       type family Foo (arg :: a) :: [Bool]
-      type Foo a = Apply Foo_0123456789876543210Sym0 a
+      type Foo a = Foo_0123456789876543210 a
     class SFoo a where
       sFoosPrec ::
-        forall (t :: Natural) (t :: a) (t :: [Bool]). Sing t
-                                                      -> Sing t
-                                                         -> Sing t
-                                                            -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool])
-      sFoo :: forall (t :: a). Sing t -> Sing (Apply FooSym0 t :: [Bool])
+        (forall (t :: Natural) (t :: a) (t :: [Bool]).
+         Sing t
+         -> Sing t -> Sing t -> Sing (FoosPrec t t t :: [Bool]) :: Type)
+      sFoo :: (forall (t :: a). Sing t -> Sing (Foo t :: [Bool]) :: Type)
       default sFoo ::
-                forall (t :: a). ((Apply FooSym0 t :: [Bool])
-                                  ~ Apply Foo_0123456789876543210Sym0 t) =>
-                                 Sing t -> Sing (Apply FooSym0 t :: [Bool])
+                (forall (t :: a).
+                 ((Foo t :: [Bool]) ~ Foo_0123456789876543210 t) =>
+                 Sing t -> Sing (Foo t :: [Bool]) :: Type)
       sFoo (sX :: Sing x)
-        = (singFun1 @(Apply Lambda_0123456789876543210Sym0 x))
-            (\ sS
-               -> case sS of
-                    (_ :: Sing s)
-                      -> (applySing
-                            ((applySing
-                                ((applySing ((singFun3 @FoosPrecSym0) sFoosPrec))
-                                   (sFromInteger (sing :: Sing 0))))
-                               sX))
-                           sS)
+        = singFun1
+            @(LamCases_0123456789876543210Sym0 a x)
+            (\cases
+               (sS :: Sing s)
+                 -> applySing
+                      (applySing
+                         (applySing
+                            (singFun3 @FoosPrecSym0 sFoosPrec) (sFromInteger (sing :: Sing 0)))
+                         sX)
+                      sS)
     instance SFoo a =>
              SingI (FoosPrecSym0 :: (~>) Natural ((~>) a ((~>) [Bool] [Bool]))) where
-      sing = (singFun3 @FoosPrecSym0) sFoosPrec
+      sing = singFun3 @FoosPrecSym0 sFoosPrec
     instance (SFoo a, SingI d) =>
              SingI (FoosPrecSym1 (d :: Natural) :: (~>) a ((~>) [Bool] [Bool])) where
       sing
-        = (singFun2 @(FoosPrecSym1 (d :: Natural))) (sFoosPrec (sing @d))
+        = singFun2 @(FoosPrecSym1 (d :: Natural)) (sFoosPrec (sing @d))
     instance SFoo a =>
              SingI1 (FoosPrecSym1 :: Natural
                                      -> (~>) a ((~>) [Bool] [Bool])) where
       liftSing (s :: Sing (d :: Natural))
-        = (singFun2 @(FoosPrecSym1 (d :: Natural))) (sFoosPrec s)
+        = singFun2 @(FoosPrecSym1 (d :: Natural)) (sFoosPrec s)
     instance (SFoo a, SingI d, SingI d) =>
              SingI (FoosPrecSym2 (d :: Natural) (d :: a) :: (~>) [Bool] [Bool]) where
       sing
-        = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a)))
-            ((sFoosPrec (sing @d)) (sing @d))
+        = singFun1
+            @(FoosPrecSym2 (d :: Natural) (d :: a))
+            (sFoosPrec (sing @d) (sing @d))
     instance (SFoo a, SingI d) =>
              SingI1 (FoosPrecSym2 (d :: Natural) :: a
                                                     -> (~>) [Bool] [Bool]) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a)))
-            ((sFoosPrec (sing @d)) s)
+        = singFun1
+            @(FoosPrecSym2 (d :: Natural) (d :: a)) (sFoosPrec (sing @d) s)
     instance SFoo a =>
              SingI2 (FoosPrecSym2 :: Natural -> a -> (~>) [Bool] [Bool]) where
       liftSing2 (s :: Sing (d :: Natural)) (s :: Sing (d :: a))
-        = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a)))
-            ((sFoosPrec s) s)
+        = singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a)) (sFoosPrec s s)
     instance SFoo a => SingI (FooSym0 :: (~>) a [Bool]) where
-      sing = (singFun1 @FooSym0) sFoo
-
-Singletons/T166.hs:0:0: error:
-    • Expecting one more argument to ‘Apply Lambda_0123456789876543210Sym0 x’
+      sing = singFun1 @FooSym0 sFoo
+Singletons/T166.hs:0:0: error: [GHC-83865]
+    • Expecting one more argument to ‘LamCases_0123456789876543210Sym0 a x’
       Expected kind ‘[Bool]’,
-        but ‘Apply Lambda_0123456789876543210Sym0 x’ has kind ‘TyFun
-                                                                 [Bool] [Bool]
-                                                               -> Type’
-    • In the type ‘Apply Lambda_0123456789876543210Sym0 x’
+        but ‘LamCases_0123456789876543210Sym0 a x’ has kind ‘TyFun
+                                                               [Bool] [Bool]
+                                                             -> Type’
+    • In the type ‘LamCases_0123456789876543210Sym0 a x’
       In the type family declaration for ‘Foo_0123456789876543210’
   |
 6 | $(singletonsOnly [d|
   |  ^^^^^^^^^^^^^^^^^^^...
+
diff --git a/tests/compile-and-dump/Singletons/T167.golden b/tests/compile-and-dump/Singletons/T167.golden
--- a/tests/compile-and-dump/Singletons/T167.golden
+++ b/tests/compile-and-dump/Singletons/T167.golden
@@ -13,183 +13,122 @@
       where
         FoosPrecSym0KindInference :: SameKind (Apply FoosPrecSym0 arg) (FoosPrecSym1 arg) =>
                                      FoosPrecSym0 a0123456789876543210
-    type instance Apply FoosPrecSym0 a0123456789876543210 = FoosPrecSym1 a0123456789876543210
+    type instance Apply @Natural @((~>) a ((~>) [Bool] [Bool])) FoosPrecSym0 a0123456789876543210 = FoosPrecSym1 a0123456789876543210
     instance SuppressUnusedWarnings FoosPrecSym0 where
-      suppressUnusedWarnings = snd (((,) FoosPrecSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FoosPrecSym0KindInference ())
     type FoosPrecSym1 :: forall a. Natural
                                    -> (~>) a ((~>) [Bool] [Bool])
     data FoosPrecSym1 (a0123456789876543210 :: Natural) :: (~>) a ((~>) [Bool] [Bool])
       where
         FoosPrecSym1KindInference :: SameKind (Apply (FoosPrecSym1 a0123456789876543210) arg) (FoosPrecSym2 a0123456789876543210 arg) =>
                                      FoosPrecSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FoosPrecSym1 a0123456789876543210) a0123456789876543210 = FoosPrecSym2 a0123456789876543210 a0123456789876543210
+    type instance Apply @a @((~>) [Bool] [Bool]) (FoosPrecSym1 a0123456789876543210) a0123456789876543210 = FoosPrecSym2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (FoosPrecSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FoosPrecSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) FoosPrecSym1KindInference ())
     type FoosPrecSym2 :: forall a. Natural -> a -> (~>) [Bool] [Bool]
     data FoosPrecSym2 (a0123456789876543210 :: Natural) (a0123456789876543210 :: a) :: (~>) [Bool] [Bool]
       where
         FoosPrecSym2KindInference :: SameKind (Apply (FoosPrecSym2 a0123456789876543210 a0123456789876543210) arg) (FoosPrecSym3 a0123456789876543210 a0123456789876543210 arg) =>
                                      FoosPrecSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (FoosPrecSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = FoosPrec a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @[Bool] @[Bool] (FoosPrecSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = FoosPrec a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (FoosPrecSym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FoosPrecSym2KindInference) ())
+      suppressUnusedWarnings = snd ((,) FoosPrecSym2KindInference ())
     type FoosPrecSym3 :: forall a. Natural -> a -> [Bool] -> [Bool]
-    type family FoosPrecSym3 (a0123456789876543210 :: Natural) (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where
+    type family FoosPrecSym3 @a (a0123456789876543210 :: Natural) (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where
       FoosPrecSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = FoosPrec a0123456789876543210 a0123456789876543210 a0123456789876543210
     type FooListSym0 :: forall a. (~>) a ((~>) [Bool] [Bool])
     data FooListSym0 :: (~>) a ((~>) [Bool] [Bool])
       where
         FooListSym0KindInference :: SameKind (Apply FooListSym0 arg) (FooListSym1 arg) =>
                                     FooListSym0 a0123456789876543210
-    type instance Apply FooListSym0 a0123456789876543210 = FooListSym1 a0123456789876543210
+    type instance Apply @a @((~>) [Bool] [Bool]) FooListSym0 a0123456789876543210 = FooListSym1 a0123456789876543210
     instance SuppressUnusedWarnings FooListSym0 where
-      suppressUnusedWarnings = snd (((,) FooListSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooListSym0KindInference ())
     type FooListSym1 :: forall a. a -> (~>) [Bool] [Bool]
     data FooListSym1 (a0123456789876543210 :: a) :: (~>) [Bool] [Bool]
       where
         FooListSym1KindInference :: SameKind (Apply (FooListSym1 a0123456789876543210) arg) (FooListSym2 a0123456789876543210 arg) =>
                                     FooListSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FooListSym1 a0123456789876543210) a0123456789876543210 = FooList a0123456789876543210 a0123456789876543210
+    type instance Apply @[Bool] @[Bool] (FooListSym1 a0123456789876543210) a0123456789876543210 = FooList a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (FooListSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FooListSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooListSym1KindInference ())
     type FooListSym2 :: forall a. a -> [Bool] -> [Bool]
-    type family FooListSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where
+    type family FooListSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where
       FooListSym2 a0123456789876543210 a0123456789876543210 = FooList a0123456789876543210 a0123456789876543210
-    type FooList_0123456789876543210 :: a -> [Bool] -> [Bool]
-    type family FooList_0123456789876543210 (a :: a) (a :: [Bool]) :: [Bool] where
-      FooList_0123456789876543210 a_0123456789876543210 a_0123456789876543210 = Apply (Apply UndefinedSym0 a_0123456789876543210) a_0123456789876543210
-    type FooList_0123456789876543210Sym0 :: (~>) a ((~>) [Bool] [Bool])
-    data FooList_0123456789876543210Sym0 :: (~>) a ((~>) [Bool] [Bool])
-      where
-        FooList_0123456789876543210Sym0KindInference :: SameKind (Apply FooList_0123456789876543210Sym0 arg) (FooList_0123456789876543210Sym1 arg) =>
-                                                        FooList_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply FooList_0123456789876543210Sym0 a0123456789876543210 = FooList_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings FooList_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) FooList_0123456789876543210Sym0KindInference) ())
-    type FooList_0123456789876543210Sym1 :: a -> (~>) [Bool] [Bool]
-    data FooList_0123456789876543210Sym1 (a0123456789876543210 :: a) :: (~>) [Bool] [Bool]
-      where
-        FooList_0123456789876543210Sym1KindInference :: SameKind (Apply (FooList_0123456789876543210Sym1 a0123456789876543210) arg) (FooList_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        FooList_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FooList_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = FooList_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (FooList_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) FooList_0123456789876543210Sym1KindInference) ())
-    type FooList_0123456789876543210Sym2 :: a -> [Bool] -> [Bool]
-    type family FooList_0123456789876543210Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where
-      FooList_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = FooList_0123456789876543210 a0123456789876543210 a0123456789876543210
+    type FooList_0123456789876543210 :: forall a. a -> [Bool] -> [Bool]
+    type family FooList_0123456789876543210 @a (a :: a) (a :: [Bool]) :: [Bool] where
+      FooList_0123456789876543210 @a (a_0123456789876543210 :: a) (a_0123456789876543210 :: [Bool]) = Apply (Apply UndefinedSym0 a_0123456789876543210) a_0123456789876543210
     class PFoo a where
       type family FoosPrec (arg :: Natural) (arg :: a) (arg :: [Bool]) :: [Bool]
       type family FooList (arg :: a) (arg :: [Bool]) :: [Bool]
-      type FooList a a = Apply (Apply FooList_0123456789876543210Sym0 a) a
-    type FoosPrec_0123456789876543210 :: Natural
-                                         -> [a] -> [Bool] -> [Bool]
-    type family FoosPrec_0123456789876543210 (a :: Natural) (a :: [a]) (a :: [Bool]) :: [Bool] where
-      FoosPrec_0123456789876543210 _ a_0123456789876543210 a_0123456789876543210 = Apply (Apply FooListSym0 a_0123456789876543210) a_0123456789876543210
-    type FoosPrec_0123456789876543210Sym0 :: (~>) Natural ((~>) [a] ((~>) [Bool] [Bool]))
-    data FoosPrec_0123456789876543210Sym0 :: (~>) Natural ((~>) [a] ((~>) [Bool] [Bool]))
-      where
-        FoosPrec_0123456789876543210Sym0KindInference :: SameKind (Apply FoosPrec_0123456789876543210Sym0 arg) (FoosPrec_0123456789876543210Sym1 arg) =>
-                                                         FoosPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply FoosPrec_0123456789876543210Sym0 a0123456789876543210 = FoosPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings FoosPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) FoosPrec_0123456789876543210Sym0KindInference) ())
-    type FoosPrec_0123456789876543210Sym1 :: Natural
-                                             -> (~>) [a] ((~>) [Bool] [Bool])
-    data FoosPrec_0123456789876543210Sym1 (a0123456789876543210 :: Natural) :: (~>) [a] ((~>) [Bool] [Bool])
-      where
-        FoosPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (FoosPrec_0123456789876543210Sym1 a0123456789876543210) arg) (FoosPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         FoosPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FoosPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = FoosPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (FoosPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) FoosPrec_0123456789876543210Sym1KindInference) ())
-    type FoosPrec_0123456789876543210Sym2 :: Natural
-                                             -> [a] -> (~>) [Bool] [Bool]
-    data FoosPrec_0123456789876543210Sym2 (a0123456789876543210 :: Natural) (a0123456789876543210 :: [a]) :: (~>) [Bool] [Bool]
-      where
-        FoosPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (FoosPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (FoosPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                         FoosPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (FoosPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = FoosPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (FoosPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) FoosPrec_0123456789876543210Sym2KindInference) ())
-    type FoosPrec_0123456789876543210Sym3 :: Natural
-                                             -> [a] -> [Bool] -> [Bool]
-    type family FoosPrec_0123456789876543210Sym3 (a0123456789876543210 :: Natural) (a0123456789876543210 :: [a]) (a0123456789876543210 :: [Bool]) :: [Bool] where
-      FoosPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = FoosPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+      type FooList a a = FooList_0123456789876543210 a a
+    type FoosPrec_0123456789876543210 :: forall a. Natural
+                                                   -> [a] -> [Bool] -> [Bool]
+    type family FoosPrec_0123456789876543210 @a (a :: Natural) (a :: [a]) (a :: [Bool]) :: [Bool] where
+      FoosPrec_0123456789876543210 @a (_ :: Natural) (a_0123456789876543210 :: [a]) (a_0123456789876543210 :: [Bool]) = Apply (Apply FooListSym0 a_0123456789876543210) a_0123456789876543210
     instance PFoo [a] where
-      type FoosPrec a a a = Apply (Apply (Apply FoosPrec_0123456789876543210Sym0 a) a) a
+      type FoosPrec a a a = FoosPrec_0123456789876543210 a a a
     class SFoo a where
       sFoosPrec ::
-        forall (t :: Natural) (t :: a) (t :: [Bool]). Sing t
-                                                      -> Sing t
-                                                         -> Sing t
-                                                            -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool])
+        (forall (t :: Natural) (t :: a) (t :: [Bool]).
+         Sing t
+         -> Sing t -> Sing t -> Sing (FoosPrec t t t :: [Bool]) :: Type)
       sFooList ::
-        forall (t :: a) (t :: [Bool]). Sing t
-                                       -> Sing t -> Sing (Apply (Apply FooListSym0 t) t :: [Bool])
+        (forall (t :: a) (t :: [Bool]).
+         Sing t -> Sing t -> Sing (FooList t t :: [Bool]) :: Type)
       default sFooList ::
-                forall (t :: a)
-                       (t :: [Bool]). ((Apply (Apply FooListSym0 t) t :: [Bool])
-                                       ~ Apply (Apply FooList_0123456789876543210Sym0 t) t) =>
-                                      Sing t
-                                      -> Sing t -> Sing (Apply (Apply FooListSym0 t) t :: [Bool])
+                (forall (t :: a) (t :: [Bool]).
+                 ((FooList t t :: [Bool]) ~ FooList_0123456789876543210 t t) =>
+                 Sing t -> Sing t -> Sing (FooList t t :: [Bool]) :: Type)
       sFooList
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (sUndefined sA_0123456789876543210) sA_0123456789876543210
+        = applySing
+            (applySing sUndefined sA_0123456789876543210)
+            sA_0123456789876543210
     instance SFoo a => SFoo [a] where
-      sFoosPrec ::
-        forall (t :: Natural) (t :: [a]) (t :: [Bool]). Sing t
-                                                        -> Sing t
-                                                           -> Sing t
-                                                              -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool])
       sFoosPrec
         _
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @FooListSym0) sFooList))
-                sA_0123456789876543210))
+        = applySing
+            (applySing (singFun2 @FooListSym0 sFooList) sA_0123456789876543210)
             sA_0123456789876543210
     instance SFoo a =>
              SingI (FoosPrecSym0 :: (~>) Natural ((~>) a ((~>) [Bool] [Bool]))) where
-      sing = (singFun3 @FoosPrecSym0) sFoosPrec
+      sing = singFun3 @FoosPrecSym0 sFoosPrec
     instance (SFoo a, SingI d) =>
              SingI (FoosPrecSym1 (d :: Natural) :: (~>) a ((~>) [Bool] [Bool])) where
       sing
-        = (singFun2 @(FoosPrecSym1 (d :: Natural))) (sFoosPrec (sing @d))
+        = singFun2 @(FoosPrecSym1 (d :: Natural)) (sFoosPrec (sing @d))
     instance SFoo a =>
              SingI1 (FoosPrecSym1 :: Natural
                                      -> (~>) a ((~>) [Bool] [Bool])) where
       liftSing (s :: Sing (d :: Natural))
-        = (singFun2 @(FoosPrecSym1 (d :: Natural))) (sFoosPrec s)
+        = singFun2 @(FoosPrecSym1 (d :: Natural)) (sFoosPrec s)
     instance (SFoo a, SingI d, SingI d) =>
              SingI (FoosPrecSym2 (d :: Natural) (d :: a) :: (~>) [Bool] [Bool]) where
       sing
-        = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a)))
-            ((sFoosPrec (sing @d)) (sing @d))
+        = singFun1
+            @(FoosPrecSym2 (d :: Natural) (d :: a))
+            (sFoosPrec (sing @d) (sing @d))
     instance (SFoo a, SingI d) =>
              SingI1 (FoosPrecSym2 (d :: Natural) :: a
                                                     -> (~>) [Bool] [Bool]) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a)))
-            ((sFoosPrec (sing @d)) s)
+        = singFun1
+            @(FoosPrecSym2 (d :: Natural) (d :: a)) (sFoosPrec (sing @d) s)
     instance SFoo a =>
              SingI2 (FoosPrecSym2 :: Natural -> a -> (~>) [Bool] [Bool]) where
       liftSing2 (s :: Sing (d :: Natural)) (s :: Sing (d :: a))
-        = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a)))
-            ((sFoosPrec s) s)
+        = singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a)) (sFoosPrec s s)
     instance SFoo a =>
              SingI (FooListSym0 :: (~>) a ((~>) [Bool] [Bool])) where
-      sing = (singFun2 @FooListSym0) sFooList
+      sing = singFun2 @FooListSym0 sFooList
     instance (SFoo a, SingI d) =>
              SingI (FooListSym1 (d :: a) :: (~>) [Bool] [Bool]) where
-      sing = (singFun1 @(FooListSym1 (d :: a))) (sFooList (sing @d))
+      sing = singFun1 @(FooListSym1 (d :: a)) (sFooList (sing @d))
     instance SFoo a =>
              SingI1 (FooListSym1 :: a -> (~>) [Bool] [Bool]) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(FooListSym1 (d :: a))) (sFooList s)
+        = singFun1 @(FooListSym1 (d :: a)) (sFooList s)
diff --git a/tests/compile-and-dump/Singletons/T172.golden b/tests/compile-and-dump/Singletons/T172.golden
--- a/tests/compile-and-dump/Singletons/T172.golden
+++ b/tests/compile-and-dump/Singletons/T172.golden
@@ -8,17 +8,17 @@
       where
         (:$>@#@$###) :: SameKind (Apply ($>@#@$) arg) (($>@#@$$) arg) =>
                         ($>@#@$) a0123456789876543210
-    type instance Apply ($>@#@$) a0123456789876543210 = ($>@#@$$) a0123456789876543210
+    type instance Apply @Natural @((~>) Natural Natural) ($>@#@$) a0123456789876543210 = ($>@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings ($>@#@$) where
-      suppressUnusedWarnings = snd (((,) (:$>@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (:$>@#@$###) ())
     type ($>@#@$$) :: Natural -> (~>) Natural Natural
     data ($>@#@$$) (a0123456789876543210 :: Natural) :: (~>) Natural Natural
       where
         (:$>@#@$$###) :: SameKind (Apply (($>@#@$$) a0123456789876543210) arg) (($>@#@$$$) a0123456789876543210 arg) =>
                          ($>@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply (($>@#@$$) a0123456789876543210) a0123456789876543210 = ($>) a0123456789876543210 a0123456789876543210
+    type instance Apply @Natural @Natural (($>@#@$$) a0123456789876543210) a0123456789876543210 = ($>) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (($>@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:$>@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (:$>@#@$$###) ())
     type ($>@#@$$$) :: Natural -> Natural -> Natural
     type family ($>@#@$$$) (a0123456789876543210 :: Natural) (a0123456789876543210 :: Natural) :: Natural where
       ($>@#@$$$) a0123456789876543210 a0123456789876543210 = ($>) a0123456789876543210 a0123456789876543210
@@ -26,21 +26,20 @@
     type family ($>) (a :: Natural) (a :: Natural) :: Natural where
       ($>) a_0123456789876543210 a_0123456789876543210 = Apply (Apply (+@#@$) a_0123456789876543210) a_0123456789876543210
     (%$>) ::
-      forall (t :: Natural) (t :: Natural). Sing t
-                                            -> Sing t
-                                               -> Sing (Apply (Apply ($>@#@$) t) t :: Natural)
+      (forall (t :: Natural) (t :: Natural).
+       Sing t -> Sing t -> Sing (($>) t t :: Natural) :: Type)
     (%$>)
       (sA_0123456789876543210 :: Sing a_0123456789876543210)
       (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing
-           ((applySing ((singFun2 @(+@#@$)) (%+))) sA_0123456789876543210))
+      = applySing
+          (applySing (singFun2 @(+@#@$) (%+)) sA_0123456789876543210)
           sA_0123456789876543210
     instance SingI (($>@#@$) :: (~>) Natural ((~>) Natural Natural)) where
-      sing = (singFun2 @($>@#@$)) (%$>)
+      sing = singFun2 @($>@#@$) (%$>)
     instance SingI d =>
              SingI (($>@#@$$) (d :: Natural) :: (~>) Natural Natural) where
-      sing = (singFun1 @(($>@#@$$) (d :: Natural))) ((%$>) (sing @d))
+      sing = singFun1 @(($>@#@$$) (d :: Natural)) ((%$>) (sing @d))
     instance SingI1 (($>@#@$$) :: Natural
                                   -> (~>) Natural Natural) where
       liftSing (s :: Sing (d :: Natural))
-        = (singFun1 @(($>@#@$$) (d :: Natural))) ((%$>) s)
+        = singFun1 @(($>@#@$$) (d :: Natural)) ((%$>) s)
diff --git a/tests/compile-and-dump/Singletons/T175.golden b/tests/compile-and-dump/Singletons/T175.golden
--- a/tests/compile-and-dump/Singletons/T175.golden
+++ b/tests/compile-and-dump/Singletons/T175.golden
@@ -19,37 +19,34 @@
     quux2 :: Bar2 a => a
     quux2 = baz
     type Quux2Sym0 :: a
-    type family Quux2Sym0 :: a where
+    type family Quux2Sym0 @a :: a where
       Quux2Sym0 = Quux2
     type Quux2 :: a
-    type family Quux2 :: a where
+    type family Quux2 @a :: a where
       Quux2 = BazSym0
     type BazSym0 :: forall a. a
-    type family BazSym0 :: a where
+    type family BazSym0 @a :: a where
       BazSym0 = Baz
     class PFoo a where
       type family Baz :: a
     type Quux1Sym0 :: forall a. a
-    type family Quux1Sym0 :: a where
+    type family Quux1Sym0 @a :: a where
       Quux1Sym0 = Quux1
-    type Quux1_0123456789876543210 :: a
-    type family Quux1_0123456789876543210 :: a where
-      Quux1_0123456789876543210 = BazSym0
-    type Quux1_0123456789876543210Sym0 :: a
-    type family Quux1_0123456789876543210Sym0 :: a where
-      Quux1_0123456789876543210Sym0 = Quux1_0123456789876543210
+    type Quux1_0123456789876543210 :: forall a. a
+    type family Quux1_0123456789876543210 @a :: a where
+      Quux1_0123456789876543210 @a = BazSym0
     class PBar1 a where
       type family Quux1 :: a
-      type Quux1 = Quux1_0123456789876543210Sym0
+      type Quux1 = Quux1_0123456789876543210
     class PBar2 a
-    sQuux2 :: forall a. SBar2 a => Sing (Quux2Sym0 :: a)
+    sQuux2 :: (SBar2 a => Sing (Quux2 :: a) :: Type)
     sQuux2 = sBaz
     class SFoo a where
-      sBaz :: Sing (BazSym0 :: a)
+      sBaz :: (Sing (Baz :: a) :: Type)
     class SFoo a => SBar1 a where
-      sQuux1 :: Sing (Quux1Sym0 :: a)
+      sQuux1 :: (Sing (Quux1 :: a) :: Type)
       default sQuux1 ::
-                ((Quux1Sym0 :: a) ~ Quux1_0123456789876543210Sym0) =>
-                Sing (Quux1Sym0 :: a)
+                (((Quux1 :: a) ~ Quux1_0123456789876543210) =>
+                 Sing (Quux1 :: a) :: Type)
       sQuux1 = sBaz
     class SFoo a => SBar2 a
diff --git a/tests/compile-and-dump/Singletons/T176.golden b/tests/compile-and-dump/Singletons/T176.golden
--- a/tests/compile-and-dump/Singletons/T176.golden
+++ b/tests/compile-and-dump/Singletons/T176.golden
@@ -22,77 +22,67 @@
       baz2 :: a
     quux2 :: Foo2 a => a -> a
     quux2 x = (x `bar2` baz2)
-    type family Case_0123456789876543210 arg_0123456789876543210 x t where
-      Case_0123456789876543210 arg_0123456789876543210 x _ = Baz1Sym0
-    type family Lambda_0123456789876543210 x arg_0123456789876543210 where
-      Lambda_0123456789876543210 x arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x arg_0123456789876543210
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 arg_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 x _ = Baz1Sym0
+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    type family Lambda_0123456789876543210Sym2 x0123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym2 x0123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 arg_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
     type Quux2Sym0 :: (~>) a a
     data Quux2Sym0 :: (~>) a a
       where
         Quux2Sym0KindInference :: SameKind (Apply Quux2Sym0 arg) (Quux2Sym1 arg) =>
                                   Quux2Sym0 a0123456789876543210
-    type instance Apply Quux2Sym0 a0123456789876543210 = Quux2 a0123456789876543210
+    type instance Apply @a @a Quux2Sym0 a0123456789876543210 = Quux2 a0123456789876543210
     instance SuppressUnusedWarnings Quux2Sym0 where
-      suppressUnusedWarnings = snd (((,) Quux2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Quux2Sym0KindInference ())
     type Quux2Sym1 :: a -> a
-    type family Quux2Sym1 (a0123456789876543210 :: a) :: a where
+    type family Quux2Sym1 @a (a0123456789876543210 :: a) :: a where
       Quux2Sym1 a0123456789876543210 = Quux2 a0123456789876543210
     type Quux1Sym0 :: (~>) a a
     data Quux1Sym0 :: (~>) a a
       where
         Quux1Sym0KindInference :: SameKind (Apply Quux1Sym0 arg) (Quux1Sym1 arg) =>
                                   Quux1Sym0 a0123456789876543210
-    type instance Apply Quux1Sym0 a0123456789876543210 = Quux1 a0123456789876543210
+    type instance Apply @a @a Quux1Sym0 a0123456789876543210 = Quux1 a0123456789876543210
     instance SuppressUnusedWarnings Quux1Sym0 where
-      suppressUnusedWarnings = snd (((,) Quux1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Quux1Sym0KindInference ())
     type Quux1Sym1 :: a -> a
-    type family Quux1Sym1 (a0123456789876543210 :: a) :: a where
+    type family Quux1Sym1 @a (a0123456789876543210 :: a) :: a where
       Quux1Sym1 a0123456789876543210 = Quux1 a0123456789876543210
     type Quux2 :: a -> a
-    type family Quux2 (a :: a) :: a where
+    type family Quux2 @a (a :: a) :: a where
       Quux2 x = Apply (Apply Bar2Sym0 x) Baz2Sym0
     type Quux1 :: a -> a
-    type family Quux1 (a :: a) :: a where
-      Quux1 x = Apply (Apply Bar1Sym0 x) (Apply Lambda_0123456789876543210Sym0 x)
+    type family Quux1 @a (a :: a) :: a where
+      Quux1 x = Apply (Apply Bar1Sym0 x) (LamCases_0123456789876543210Sym0 x)
     type Bar1Sym0 :: forall a b. (~>) a ((~>) ((~>) a b) b)
     data Bar1Sym0 :: (~>) a ((~>) ((~>) a b) b)
       where
         Bar1Sym0KindInference :: SameKind (Apply Bar1Sym0 arg) (Bar1Sym1 arg) =>
                                  Bar1Sym0 a0123456789876543210
-    type instance Apply Bar1Sym0 a0123456789876543210 = Bar1Sym1 a0123456789876543210
+    type instance Apply @a @((~>) ((~>) a b) b) Bar1Sym0 a0123456789876543210 = Bar1Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Bar1Sym0 where
-      suppressUnusedWarnings = snd (((,) Bar1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Bar1Sym0KindInference ())
     type Bar1Sym1 :: forall a b. a -> (~>) ((~>) a b) b
     data Bar1Sym1 (a0123456789876543210 :: a) :: (~>) ((~>) a b) b
       where
         Bar1Sym1KindInference :: SameKind (Apply (Bar1Sym1 a0123456789876543210) arg) (Bar1Sym2 a0123456789876543210 arg) =>
                                  Bar1Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Bar1Sym1 a0123456789876543210) a0123456789876543210 = Bar1 a0123456789876543210 a0123456789876543210
+    type instance Apply @((~>) a b) @b (Bar1Sym1 a0123456789876543210) a0123456789876543210 = Bar1 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Bar1Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Bar1Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Bar1Sym1KindInference ())
     type Bar1Sym2 :: forall a b. a -> (~>) a b -> b
-    type family Bar1Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: (~>) a b) :: b where
+    type family Bar1Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: (~>) a b) :: b where
       Bar1Sym2 a0123456789876543210 a0123456789876543210 = Bar1 a0123456789876543210 a0123456789876543210
     type Baz1Sym0 :: forall a. a
-    type family Baz1Sym0 :: a where
+    type family Baz1Sym0 @a :: a where
       Baz1Sym0 = Baz1
     class PFoo1 a where
       type family Bar1 (arg :: a) (arg :: (~>) a b) :: b
@@ -102,72 +92,66 @@
       where
         Bar2Sym0KindInference :: SameKind (Apply Bar2Sym0 arg) (Bar2Sym1 arg) =>
                                  Bar2Sym0 a0123456789876543210
-    type instance Apply Bar2Sym0 a0123456789876543210 = Bar2Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b b) Bar2Sym0 a0123456789876543210 = Bar2Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Bar2Sym0 where
-      suppressUnusedWarnings = snd (((,) Bar2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Bar2Sym0KindInference ())
     type Bar2Sym1 :: forall a b. a -> (~>) b b
     data Bar2Sym1 (a0123456789876543210 :: a) :: (~>) b b
       where
         Bar2Sym1KindInference :: SameKind (Apply (Bar2Sym1 a0123456789876543210) arg) (Bar2Sym2 a0123456789876543210 arg) =>
                                  Bar2Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Bar2Sym1 a0123456789876543210) a0123456789876543210 = Bar2 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @b (Bar2Sym1 a0123456789876543210) a0123456789876543210 = Bar2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Bar2Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Bar2Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Bar2Sym1KindInference ())
     type Bar2Sym2 :: forall a b. a -> b -> b
-    type family Bar2Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
+    type family Bar2Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
       Bar2Sym2 a0123456789876543210 a0123456789876543210 = Bar2 a0123456789876543210 a0123456789876543210
     type Baz2Sym0 :: forall a. a
-    type family Baz2Sym0 :: a where
+    type family Baz2Sym0 @a :: a where
       Baz2Sym0 = Baz2
     class PFoo2 a where
       type family Bar2 (arg :: a) (arg :: b) :: b
       type family Baz2 :: a
     sQuux2 ::
-      forall a (t :: a). SFoo2 a =>
-                         Sing t -> Sing (Apply Quux2Sym0 t :: a)
+      (forall (t :: a). SFoo2 a => Sing t -> Sing (Quux2 t :: a) :: Type)
     sQuux1 ::
-      forall a (t :: a). SFoo1 a =>
-                         Sing t -> Sing (Apply Quux1Sym0 t :: a)
+      (forall (t :: a). SFoo1 a => Sing t -> Sing (Quux1 t :: a) :: Type)
     sQuux2 (sX :: Sing x)
-      = (applySing ((applySing ((singFun2 @Bar2Sym0) sBar2)) sX)) sBaz2
+      = applySing (applySing (singFun2 @Bar2Sym0 sBar2) sX) sBaz2
     sQuux1 (sX :: Sing x)
-      = (applySing ((applySing ((singFun2 @Bar1Sym0) sBar1)) sX))
-          ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x))
-             (\ sArg_0123456789876543210
-                -> case sArg_0123456789876543210 of
-                     (_ :: Sing arg_0123456789876543210)
-                       -> (id
-                             @(Sing (Case_0123456789876543210 arg_0123456789876543210 x arg_0123456789876543210)))
-                            (case sArg_0123456789876543210 of _ -> sBaz1)))
+      = applySing
+          (applySing (singFun2 @Bar1Sym0 sBar1) sX)
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 x) (\cases _ -> sBaz1))
     instance SFoo2 a => SingI (Quux2Sym0 :: (~>) a a) where
-      sing = (singFun1 @Quux2Sym0) sQuux2
+      sing = singFun1 @Quux2Sym0 sQuux2
     instance SFoo1 a => SingI (Quux1Sym0 :: (~>) a a) where
-      sing = (singFun1 @Quux1Sym0) sQuux1
+      sing = singFun1 @Quux1Sym0 sQuux1
     class SFoo1 a where
       sBar1 ::
-        forall b (t :: a) (t :: (~>) a b). Sing t
-                                           -> Sing t -> Sing (Apply (Apply Bar1Sym0 t) t :: b)
-      sBaz1 :: Sing (Baz1Sym0 :: a)
+        (forall (t :: a) (t :: (~>) a b).
+         Sing t -> Sing t -> Sing (Bar1 t t :: b) :: Type)
+      sBaz1 :: (Sing (Baz1 :: a) :: Type)
     class SFoo2 a where
       sBar2 ::
-        forall b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply Bar2Sym0 t) t :: b)
-      sBaz2 :: Sing (Baz2Sym0 :: a)
+        (forall (t :: a) (t :: b).
+         Sing t -> Sing t -> Sing (Bar2 t t :: b) :: Type)
+      sBaz2 :: (Sing (Baz2 :: a) :: Type)
     instance SFoo1 a =>
              SingI (Bar1Sym0 :: (~>) a ((~>) ((~>) a b) b)) where
-      sing = (singFun2 @Bar1Sym0) sBar1
+      sing = singFun2 @Bar1Sym0 sBar1
     instance (SFoo1 a, SingI d) =>
              SingI (Bar1Sym1 (d :: a) :: (~>) ((~>) a b) b) where
-      sing = (singFun1 @(Bar1Sym1 (d :: a))) (sBar1 (sing @d))
+      sing = singFun1 @(Bar1Sym1 (d :: a)) (sBar1 (sing @d))
     instance SFoo1 a =>
              SingI1 (Bar1Sym1 :: a -> (~>) ((~>) a b) b) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Bar1Sym1 (d :: a))) (sBar1 s)
+        = singFun1 @(Bar1Sym1 (d :: a)) (sBar1 s)
     instance SFoo2 a => SingI (Bar2Sym0 :: (~>) a ((~>) b b)) where
-      sing = (singFun2 @Bar2Sym0) sBar2
+      sing = singFun2 @Bar2Sym0 sBar2
     instance (SFoo2 a, SingI d) =>
              SingI (Bar2Sym1 (d :: a) :: (~>) b b) where
-      sing = (singFun1 @(Bar2Sym1 (d :: a))) (sBar2 (sing @d))
+      sing = singFun1 @(Bar2Sym1 (d :: a)) (sBar2 (sing @d))
     instance SFoo2 a => SingI1 (Bar2Sym1 :: a -> (~>) b b) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Bar2Sym1 (d :: a))) (sBar2 s)
+        = singFun1 @(Bar2Sym1 (d :: a)) (sBar2 s)
diff --git a/tests/compile-and-dump/Singletons/T178.golden b/tests/compile-and-dump/Singletons/T178.golden
--- a/tests/compile-and-dump/Singletons/T178.golden
+++ b/tests/compile-and-dump/Singletons/T178.golden
@@ -42,105 +42,30 @@
       TFHelper_0123456789876543210 Many Str = FalseSym0
       TFHelper_0123456789876543210 Many Opt = FalseSym0
       TFHelper_0123456789876543210 Many Many = TrueSym0
-    type TFHelper_0123456789876543210Sym0 :: (~>) Occ ((~>) Occ Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) Occ ((~>) Occ Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Occ -> (~>) Occ Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Occ) :: (~>) Occ Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Occ -> Occ -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Occ) (a0123456789876543210 :: Occ) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PEq Occ where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
+      type (==) a a = TFHelper_0123456789876543210 a a
     type Compare_0123456789876543210 :: Occ -> Occ -> Ordering
     type family Compare_0123456789876543210 (a :: Occ) (a :: Occ) :: Ordering where
-      Compare_0123456789876543210 Str Str = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
-      Compare_0123456789876543210 Opt Opt = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
-      Compare_0123456789876543210 Many Many = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
+      Compare_0123456789876543210 Str Str = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
+      Compare_0123456789876543210 Opt Opt = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
+      Compare_0123456789876543210 Many Many = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
       Compare_0123456789876543210 Str Opt = LTSym0
       Compare_0123456789876543210 Str Many = LTSym0
       Compare_0123456789876543210 Opt Str = GTSym0
       Compare_0123456789876543210 Opt Many = LTSym0
       Compare_0123456789876543210 Many Str = GTSym0
       Compare_0123456789876543210 Many Opt = GTSym0
-    type Compare_0123456789876543210Sym0 :: (~>) Occ ((~>) Occ Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) Occ ((~>) Occ Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: Occ -> (~>) Occ Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Occ) :: (~>) Occ Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: Occ -> Occ -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: Occ) (a0123456789876543210 :: Occ) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance POrd Occ where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
+      type Compare a a = Compare_0123456789876543210 a a
     type ShowsPrec_0123456789876543210 :: Natural
                                           -> Occ -> Symbol -> Symbol
     type family ShowsPrec_0123456789876543210 (a :: Natural) (a :: Occ) (a :: Symbol) :: Symbol where
       ShowsPrec_0123456789876543210 _ Str a_0123456789876543210 = Apply (Apply ShowStringSym0 "Str") a_0123456789876543210
       ShowsPrec_0123456789876543210 _ Opt a_0123456789876543210 = Apply (Apply ShowStringSym0 "Opt") a_0123456789876543210
       ShowsPrec_0123456789876543210 _ Many a_0123456789876543210 = Apply (Apply ShowStringSym0 "Many") a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) Natural ((~>) Occ ((~>) Symbol Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) Natural ((~>) Occ ((~>) Symbol Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: Natural
-                                              -> (~>) Occ ((~>) Symbol Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: Natural) :: (~>) Occ ((~>) Symbol Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: Natural
-                                              -> Occ -> (~>) Symbol Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: Natural) (a0123456789876543210 :: Occ) :: (~>) Symbol Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: Natural
-                                              -> Occ -> Symbol -> Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: Natural) (a0123456789876543210 :: Occ) (a0123456789876543210 :: Symbol) :: Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PShow Occ where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
-    sEmpty :: Sing (EmptySym0 :: [(Symbol, Occ)])
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
+    sEmpty :: (Sing (Empty :: [(Symbol, Occ)]) :: Type)
     sEmpty = SNil
     data SOcc :: Occ -> Type
       where
@@ -157,11 +82,6 @@
       toSing Opt = SomeSing SOpt
       toSing Many = SomeSing SMany
     instance SEq Occ where
-      (%==) ::
-        forall (t1 :: Occ) (t2 :: Occ). Sing t1
-                                        -> Sing t2
-                                           -> Sing (Apply (Apply ((==@#@$) :: TyFun Occ ((~>) Occ Bool)
-                                                                              -> Type) t1) t2)
       (%==) SStr SStr = STrue
       (%==) SStr SOpt = SFalse
       (%==) SStr SMany = SFalse
@@ -172,31 +92,23 @@
       (%==) SMany SOpt = SFalse
       (%==) SMany SMany = STrue
     instance SOrd Occ where
-      sCompare ::
-        forall (t1 :: Occ) (t2 :: Occ). Sing t1
-                                        -> Sing t2
-                                           -> Sing (Apply (Apply (CompareSym0 :: TyFun Occ ((~>) Occ Ordering)
-                                                                                 -> Type) t1) t2)
       sCompare SStr SStr
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
             SNil
       sCompare SOpt SOpt
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
             SNil
       sCompare SMany SMany
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
             SNil
       sCompare SStr SOpt = SLT
       sCompare SStr SMany = SLT
@@ -205,54 +117,52 @@
       sCompare SMany SStr = SGT
       sCompare SMany SOpt = SGT
     instance SShow Occ where
-      sShowsPrec ::
-        forall (t1 :: Natural) (t2 :: Occ) (t3 :: Symbol). Sing t1
-                                                           -> Sing t2
-                                                              -> Sing t3
-                                                                 -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun Natural ((~>) Occ ((~>) Symbol Symbol))
-                                                                                                                -> Type) t1) t2) t3)
       sShowsPrec
         _
         SStr
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "Str")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Str"))
             sA_0123456789876543210
       sShowsPrec
         _
         SOpt
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "Opt")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Opt"))
             sA_0123456789876543210
       sShowsPrec
         _
         SMany
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "Many")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Many"))
             sA_0123456789876543210
     instance SDecide Occ where
       (%~) SStr SStr = Proved Refl
-      (%~) SStr SOpt = Disproved (\ x -> case x of {})
-      (%~) SStr SMany = Disproved (\ x -> case x of {})
-      (%~) SOpt SStr = Disproved (\ x -> case x of {})
+      (%~) SStr SOpt = Disproved (\case)
+      (%~) SStr SMany = Disproved (\case)
+      (%~) SOpt SStr = Disproved (\case)
       (%~) SOpt SOpt = Proved Refl
-      (%~) SOpt SMany = Disproved (\ x -> case x of {})
-      (%~) SMany SStr = Disproved (\ x -> case x of {})
-      (%~) SMany SOpt = Disproved (\ x -> case x of {})
+      (%~) SOpt SMany = Disproved (\case)
+      (%~) SMany SStr = Disproved (\case)
+      (%~) SMany SOpt = Disproved (\case)
       (%~) SMany SMany = Proved Refl
-    instance Data.Type.Equality.TestEquality (SOcc :: Occ
-                                                      -> Type) where
-      Data.Type.Equality.testEquality
+    instance Eq (SOcc (z :: Occ)) where
+      (==) _ _ = True
+    instance GHC.Internal.Data.Type.Equality.TestEquality (SOcc :: Occ
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
         = Data.Singletons.Decide.decideEquality
-    instance Data.Type.Coercion.TestCoercion (SOcc :: Occ
-                                                      -> Type) where
-      Data.Type.Coercion.testCoercion
+    instance GHC.Internal.Data.Type.Coercion.TestCoercion (SOcc :: Occ
+                                                                   -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
         = Data.Singletons.Decide.decideCoercion
+    instance Ord (SOcc (z :: Occ)) where
+      compare _ _ = EQ
     deriving instance Show (SOcc (z :: Occ))
     instance SingI Str where
       sing = SStr
diff --git a/tests/compile-and-dump/Singletons/T183.golden b/tests/compile-and-dump/Singletons/T183.golden
--- a/tests/compile-and-dump/Singletons/T183.golden
+++ b/tests/compile-and-dump/Singletons/T183.golden
@@ -58,466 +58,423 @@
       = let
           g :: a -> b -> a
           g y _ = y
-        in (g x) ()
-    data Let0123456789876543210GSym0 x0123456789876543210
-      where
-        Let0123456789876543210GSym0KindInference :: SameKind (Apply Let0123456789876543210GSym0 arg) (Let0123456789876543210GSym1 arg) =>
-                                                    Let0123456789876543210GSym0 x0123456789876543210
-    type instance Apply Let0123456789876543210GSym0 x0123456789876543210 = Let0123456789876543210GSym1 x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210GSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210GSym0KindInference) ())
-    data Let0123456789876543210GSym1 x0123456789876543210 :: (~>) a ((~>) b0123456789876543210 a)
-      where
-        Let0123456789876543210GSym1KindInference :: SameKind (Apply (Let0123456789876543210GSym1 x0123456789876543210) arg) (Let0123456789876543210GSym2 x0123456789876543210 arg) =>
-                                                    Let0123456789876543210GSym1 x0123456789876543210 a0123456789876543210
-    type instance Apply (Let0123456789876543210GSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210GSym1 x0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210GSym1KindInference) ())
-    data Let0123456789876543210GSym2 x0123456789876543210 (a0123456789876543210 :: a) :: (~>) b0123456789876543210 a
-      where
-        Let0123456789876543210GSym2KindInference :: SameKind (Apply (Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210) arg) (Let0123456789876543210GSym3 x0123456789876543210 a0123456789876543210 arg) =>
-                                                    Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210) a0123456789876543210 = Let0123456789876543210G x0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210GSym2KindInference) ())
-    type family Let0123456789876543210GSym3 x0123456789876543210 (a0123456789876543210 :: a) (a0123456789876543210 :: b0123456789876543210) :: a where
-      Let0123456789876543210GSym3 x0123456789876543210 a0123456789876543210 a0123456789876543210 = Let0123456789876543210G x0123456789876543210 a0123456789876543210 a0123456789876543210
-    type family Let0123456789876543210G x (a :: a) (a :: b) :: a where
-      Let0123456789876543210G x y _ = y
-    data Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210
+        in g x ()
+    data Let0123456789876543210GSym0 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)
       where
-        Let0123456789876543210XSym0KindInference :: SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>
-                                                    Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210
-    type instance Apply Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210X wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where
+        Let0123456789876543210GSym0KindInference :: SameKind (Apply (Let0123456789876543210GSym0 a0123456789876543210 x0123456789876543210) arg) (Let0123456789876543210GSym1 a0123456789876543210 x0123456789876543210 arg) =>
+                                                    Let0123456789876543210GSym0 a0123456789876543210 x0123456789876543210 a0123456789876543210
+    type instance Apply @a0123456789876543210 @((~>) b0123456789876543210 a0123456789876543210) (Let0123456789876543210GSym0 a0123456789876543210 x0123456789876543210) a0123456789876543210 = Let0123456789876543210GSym1 a0123456789876543210 x0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Let0123456789876543210GSym0 a0123456789876543210 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210XSym0KindInference) ())
-    type family Let0123456789876543210XSym1 wild_01234567898765432100123456789876543210 where
-      Let0123456789876543210XSym1 wild_01234567898765432100123456789876543210 = Let0123456789876543210X wild_01234567898765432100123456789876543210
-    type family Let0123456789876543210X wild_0123456789876543210 where
-      Let0123456789876543210X wild_0123456789876543210 = Apply JustSym0 (wild_0123456789876543210 :: a) :: Maybe a
-    type family Let0123456789876543210XSym0 where
-      Let0123456789876543210XSym0 = Let0123456789876543210X
-    type family Let0123456789876543210X where
-      Let0123456789876543210X = NothingSym0 :: Maybe a
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210
+        = snd ((,) Let0123456789876543210GSym0KindInference ())
+    data Let0123456789876543210GSym1 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: a0123456789876543210) :: (~>) b0123456789876543210 a0123456789876543210
       where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where
+        Let0123456789876543210GSym1KindInference :: SameKind (Apply (Let0123456789876543210GSym1 a0123456789876543210 x0123456789876543210 a0123456789876543210) arg) (Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210 a0123456789876543210 arg) =>
+                                                    Let0123456789876543210GSym1 a0123456789876543210 x0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @b0123456789876543210 @a0123456789876543210 (Let0123456789876543210GSym1 a0123456789876543210 x0123456789876543210 a0123456789876543210) a0123456789876543210 = Let0123456789876543210G a0123456789876543210 x0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Let0123456789876543210GSym1 a0123456789876543210 x0123456789876543210 a0123456789876543210) where
       suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)
-               ())
-    type family Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 where
-      Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210
-    type family Let0123456789876543210Scrutinee_0123456789876543210 x where
-      Let0123456789876543210Scrutinee_0123456789876543210 x = x :: Maybe a
-    type family Case_0123456789876543210 x t where
-      Case_0123456789876543210 x ('Just (y :: a) :: Maybe a) = Apply JustSym0 (Apply JustSym0 (y :: a) :: Maybe a)
-    type family Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 t where
-      Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 '(x :: a,
-                                                                               y :: b) = Apply (Apply Tuple2Sym0 (y :: b)) (x :: a)
-    type family Lambda_0123456789876543210 a_0123456789876543210 arg_0123456789876543210 where
-      Lambda_0123456789876543210 a_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 arg_0123456789876543210
-    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+        = snd ((,) Let0123456789876543210GSym1KindInference ())
+    type family Let0123456789876543210GSym2 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) :: a0123456789876543210 where
+      Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210 a0123456789876543210 a0123456789876543210 = Let0123456789876543210G a0123456789876543210 x0123456789876543210 a0123456789876543210 a0123456789876543210
+    type family Let0123456789876543210G a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) (a :: a0123456789876543210) (a :: b) :: a0123456789876543210 where
+      Let0123456789876543210G a x y _ = y
+    type family Let0123456789876543210XSym0 a0123456789876543210 (wild_01234567898765432100123456789876543210 :: a0123456789876543210) where
+      Let0123456789876543210XSym0 a0123456789876543210 wild_01234567898765432100123456789876543210 = Let0123456789876543210X a0123456789876543210 wild_01234567898765432100123456789876543210
+    type family Let0123456789876543210X a0123456789876543210 (wild_01234567898765432100123456789876543210 :: a0123456789876543210) where
+      Let0123456789876543210X a wild_0123456789876543210 = Apply JustSym0 (wild_0123456789876543210 :: a) :: Maybe a
+    type family Let0123456789876543210XSym0 a0123456789876543210 where
+      Let0123456789876543210XSym0 a0123456789876543210 = Let0123456789876543210X a0123456789876543210
+    type family Let0123456789876543210X a0123456789876543210 where
+      Let0123456789876543210X a = NothingSym0 :: Maybe a
+    type family LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 a x ('Just (y :: a) :: Maybe a) = Apply JustSym0 (Apply JustSym0 (y :: a) :: Maybe a)
+    data LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (a_01234567898765432100123456789876543210 :: (a0123456789876543210,
+                                                                                           b0123456789876543210)) a_0123456789876543210 where
+      LamCases_0123456789876543210 a_0123456789876543210 '(x :: a,
+                                                           y :: b) = Apply (Apply Tuple2Sym0 (y :: b)) (x :: a)
+    data LamCases_0123456789876543210Sym0 (a_01234567898765432100123456789876543210 :: (a0123456789876543210,
+                                                                                        b0123456789876543210)) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    type family Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (a_01234567898765432100123456789876543210 :: (a0123456789876543210,
+                                                                                               b0123456789876543210)) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 x ('Just y :: Maybe Bool) = y :: Bool
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210) where
       suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)
-               ())
-    type family Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 where
-      Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210
-    type family Let0123456789876543210Scrutinee_0123456789876543210 x where
-      Let0123456789876543210Scrutinee_0123456789876543210 x = Apply JustSym0 x
-    type family Case_0123456789876543210 x t where
-      Case_0123456789876543210 x ('Just y :: Maybe Bool) = y :: Bool
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210
     type Foo9Sym0 :: (~>) a a
     data Foo9Sym0 :: (~>) a a
       where
         Foo9Sym0KindInference :: SameKind (Apply Foo9Sym0 arg) (Foo9Sym1 arg) =>
                                  Foo9Sym0 a0123456789876543210
-    type instance Apply Foo9Sym0 a0123456789876543210 = Foo9 a0123456789876543210
+    type instance Apply @a @a Foo9Sym0 a0123456789876543210 = Foo9 a0123456789876543210
     instance SuppressUnusedWarnings Foo9Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo9Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo9Sym0KindInference ())
     type Foo9Sym1 :: a -> a
-    type family Foo9Sym1 (a0123456789876543210 :: a) :: a where
+    type family Foo9Sym1 @a (a0123456789876543210 :: a) :: a where
       Foo9Sym1 a0123456789876543210 = Foo9 a0123456789876543210
     type Foo8Sym0 :: forall a. (~>) (Maybe a) (Maybe a)
     data Foo8Sym0 :: (~>) (Maybe a) (Maybe a)
       where
         Foo8Sym0KindInference :: SameKind (Apply Foo8Sym0 arg) (Foo8Sym1 arg) =>
                                  Foo8Sym0 a0123456789876543210
-    type instance Apply Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210
+    type instance Apply @(Maybe a) @(Maybe a) Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210
     instance SuppressUnusedWarnings Foo8Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo8Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo8Sym0KindInference ())
     type Foo8Sym1 :: forall a. Maybe a -> Maybe a
-    type family Foo8Sym1 (a0123456789876543210 :: Maybe a) :: Maybe a where
+    type family Foo8Sym1 @a (a0123456789876543210 :: Maybe a) :: Maybe a where
       Foo8Sym1 a0123456789876543210 = Foo8 a0123456789876543210
     type Foo7Sym0 :: (~>) a ((~>) b a)
     data Foo7Sym0 :: (~>) a ((~>) b a)
       where
         Foo7Sym0KindInference :: SameKind (Apply Foo7Sym0 arg) (Foo7Sym1 arg) =>
                                  Foo7Sym0 a0123456789876543210
-    type instance Apply Foo7Sym0 a0123456789876543210 = Foo7Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b a) Foo7Sym0 a0123456789876543210 = Foo7Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Foo7Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo7Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo7Sym0KindInference ())
     type Foo7Sym1 :: a -> (~>) b a
     data Foo7Sym1 (a0123456789876543210 :: a) :: (~>) b a
       where
         Foo7Sym1KindInference :: SameKind (Apply (Foo7Sym1 a0123456789876543210) arg) (Foo7Sym2 a0123456789876543210 arg) =>
                                  Foo7Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Foo7Sym1 a0123456789876543210) a0123456789876543210 = Foo7 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @a (Foo7Sym1 a0123456789876543210) a0123456789876543210 = Foo7 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Foo7Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Foo7Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo7Sym1KindInference ())
     type Foo7Sym2 :: a -> b -> a
-    type family Foo7Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
+    type family Foo7Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
       Foo7Sym2 a0123456789876543210 a0123456789876543210 = Foo7 a0123456789876543210 a0123456789876543210
     type Foo6Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))
     data Foo6Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))
       where
         Foo6Sym0KindInference :: SameKind (Apply Foo6Sym0 arg) (Foo6Sym1 arg) =>
                                  Foo6Sym0 a0123456789876543210
-    type instance Apply Foo6Sym0 a0123456789876543210 = Foo6 a0123456789876543210
+    type instance Apply @(Maybe (Maybe a)) @(Maybe (Maybe a)) Foo6Sym0 a0123456789876543210 = Foo6 a0123456789876543210
     instance SuppressUnusedWarnings Foo6Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo6Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo6Sym0KindInference ())
     type Foo6Sym1 :: Maybe (Maybe a) -> Maybe (Maybe a)
-    type family Foo6Sym1 (a0123456789876543210 :: Maybe (Maybe a)) :: Maybe (Maybe a) where
+    type family Foo6Sym1 @a (a0123456789876543210 :: Maybe (Maybe a)) :: Maybe (Maybe a) where
       Foo6Sym1 a0123456789876543210 = Foo6 a0123456789876543210
     type Foo5Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))
     data Foo5Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))
       where
         Foo5Sym0KindInference :: SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>
                                  Foo5Sym0 a0123456789876543210
-    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210
+    type instance Apply @(Maybe (Maybe a)) @(Maybe (Maybe a)) Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210
     instance SuppressUnusedWarnings Foo5Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo5Sym0KindInference ())
     type Foo5Sym1 :: Maybe (Maybe a) -> Maybe (Maybe a)
-    type family Foo5Sym1 (a0123456789876543210 :: Maybe (Maybe a)) :: Maybe (Maybe a) where
+    type family Foo5Sym1 @a (a0123456789876543210 :: Maybe (Maybe a)) :: Maybe (Maybe a) where
       Foo5Sym1 a0123456789876543210 = Foo5 a0123456789876543210
     type Foo4Sym0 :: (~>) (a, b) (b, a)
     data Foo4Sym0 :: (~>) (a, b) (b, a)
       where
         Foo4Sym0KindInference :: SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>
                                  Foo4Sym0 a0123456789876543210
-    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210
+    type instance Apply @(a, b) @(b,
+                                  a) Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210
     instance SuppressUnusedWarnings Foo4Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo4Sym0KindInference ())
     type Foo4Sym1 :: (a, b) -> (b, a)
-    type family Foo4Sym1 (a0123456789876543210 :: (a, b)) :: (b,
-                                                              a) where
+    type family Foo4Sym1 @a @b (a0123456789876543210 :: (a, b)) :: (b,
+                                                                    a) where
       Foo4Sym1 a0123456789876543210 = Foo4 a0123456789876543210
     type Foo3Sym0 :: forall a. (~>) (Maybe a) a
     data Foo3Sym0 :: (~>) (Maybe a) a
       where
         Foo3Sym0KindInference :: SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>
                                  Foo3Sym0 a0123456789876543210
-    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210
+    type instance Apply @(Maybe a) @a Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210
     instance SuppressUnusedWarnings Foo3Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo3Sym0KindInference ())
     type Foo3Sym1 :: forall a. Maybe a -> a
-    type family Foo3Sym1 (a0123456789876543210 :: Maybe a) :: a where
+    type family Foo3Sym1 @a (a0123456789876543210 :: Maybe a) :: a where
       Foo3Sym1 a0123456789876543210 = Foo3 a0123456789876543210
     type Foo2Sym0 :: forall a. (~>) (Maybe a) a
     data Foo2Sym0 :: (~>) (Maybe a) a
       where
         Foo2Sym0KindInference :: SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>
                                  Foo2Sym0 a0123456789876543210
-    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2 a0123456789876543210
+    type instance Apply @(Maybe a) @a Foo2Sym0 a0123456789876543210 = Foo2 a0123456789876543210
     instance SuppressUnusedWarnings Foo2Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo2Sym0KindInference ())
     type Foo2Sym1 :: forall a. Maybe a -> a
-    type family Foo2Sym1 (a0123456789876543210 :: Maybe a) :: a where
+    type family Foo2Sym1 @a (a0123456789876543210 :: Maybe a) :: a where
       Foo2Sym1 a0123456789876543210 = Foo2 a0123456789876543210
     type Foo1Sym0 :: (~>) (Maybe a) a
     data Foo1Sym0 :: (~>) (Maybe a) a
       where
         Foo1Sym0KindInference :: SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>
                                  Foo1Sym0 a0123456789876543210
-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210
+    type instance Apply @(Maybe a) @a Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210
     instance SuppressUnusedWarnings Foo1Sym0 where
-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Foo1Sym0KindInference ())
     type Foo1Sym1 :: Maybe a -> a
-    type family Foo1Sym1 (a0123456789876543210 :: Maybe a) :: a where
+    type family Foo1Sym1 @a (a0123456789876543210 :: Maybe a) :: a where
       Foo1Sym1 a0123456789876543210 = Foo1 a0123456789876543210
     data GSym0 a0123456789876543210
       where
         GSym0KindInference :: SameKind (Apply GSym0 arg) (GSym1 arg) =>
                               GSym0 a0123456789876543210
-    type instance Apply GSym0 a0123456789876543210 = G a0123456789876543210
+    type instance Apply @_ @_ GSym0 a0123456789876543210 = G a0123456789876543210
     instance SuppressUnusedWarnings GSym0 where
-      suppressUnusedWarnings = snd (((,) GSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) GSym0KindInference ())
     type family GSym1 a0123456789876543210 where
       GSym1 a0123456789876543210 = G a0123456789876543210
     data F3Sym0 a0123456789876543210
       where
         F3Sym0KindInference :: SameKind (Apply F3Sym0 arg) (F3Sym1 arg) =>
                                F3Sym0 a0123456789876543210
-    type instance Apply F3Sym0 a0123456789876543210 = F3 a0123456789876543210
+    type instance Apply @_ @_ F3Sym0 a0123456789876543210 = F3 a0123456789876543210
     instance SuppressUnusedWarnings F3Sym0 where
-      suppressUnusedWarnings = snd (((,) F3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) F3Sym0KindInference ())
     type family F3Sym1 a0123456789876543210 where
       F3Sym1 a0123456789876543210 = F3 a0123456789876543210
     data F2Sym0 a0123456789876543210
       where
         F2Sym0KindInference :: SameKind (Apply F2Sym0 arg) (F2Sym1 arg) =>
                                F2Sym0 a0123456789876543210
-    type instance Apply F2Sym0 a0123456789876543210 = F2 a0123456789876543210
+    type instance Apply @_ @_ F2Sym0 a0123456789876543210 = F2 a0123456789876543210
     instance SuppressUnusedWarnings F2Sym0 where
-      suppressUnusedWarnings = snd (((,) F2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) F2Sym0KindInference ())
     type family F2Sym1 a0123456789876543210 where
       F2Sym1 a0123456789876543210 = F2 a0123456789876543210
     data F1Sym0 a0123456789876543210
       where
         F1Sym0KindInference :: SameKind (Apply F1Sym0 arg) (F1Sym1 arg) =>
                                F1Sym0 a0123456789876543210
-    type instance Apply F1Sym0 a0123456789876543210 = F1 a0123456789876543210
+    type instance Apply @_ @_ F1Sym0 a0123456789876543210 = F1 a0123456789876543210
     instance SuppressUnusedWarnings F1Sym0 where
-      suppressUnusedWarnings = snd (((,) F1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) F1Sym0KindInference ())
     type family F1Sym1 a0123456789876543210 where
       F1Sym1 a0123456789876543210 = F1 a0123456789876543210
     type Foo9 :: a -> a
-    type family Foo9 (a :: a) :: a where
-      Foo9 (x :: a) = Apply (Apply (Let0123456789876543210GSym1 x) x) Tuple0Sym0
+    type family Foo9 @a (a :: a) :: a where
+      Foo9 (x :: a) = Apply (Apply (Let0123456789876543210GSym0 a x) x) Tuple0Sym0
     type Foo8 :: forall a. Maybe a -> Maybe a
-    type family Foo8 (a :: Maybe a) :: Maybe a where
-      Foo8 ('Just (wild_0123456789876543210 :: a) :: Maybe a) = Let0123456789876543210XSym1 wild_0123456789876543210
-      Foo8 ('Nothing :: Maybe a) = Let0123456789876543210XSym0
+    type family Foo8 @a (a :: Maybe a) :: Maybe a where
+      Foo8 @a ('Just (wild_0123456789876543210 :: a) :: Maybe a :: Maybe a) = Let0123456789876543210XSym0 a wild_0123456789876543210
+      Foo8 @a ('Nothing :: Maybe a :: Maybe a) = Let0123456789876543210XSym0 a
     type Foo7 :: a -> b -> a
-    type family Foo7 (a :: a) (a :: b) :: a where
+    type family Foo7 @a @b (a :: a) (a :: b) :: a where
       Foo7 (x :: a) (wild_0123456789876543210 :: b) = x :: a
     type Foo6 :: Maybe (Maybe a) -> Maybe (Maybe a)
-    type family Foo6 (a :: Maybe (Maybe a)) :: Maybe (Maybe a) where
-      Foo6 ('Just x :: Maybe (Maybe a)) = Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)
+    type family Foo6 @a (a :: Maybe (Maybe a)) :: Maybe (Maybe a) where
+      Foo6 ('Just x :: Maybe (Maybe a)) = Apply (LamCases_0123456789876543210Sym0 a x) (x :: Maybe a)
     type Foo5 :: Maybe (Maybe a) -> Maybe (Maybe a)
-    type family Foo5 (a :: Maybe (Maybe a)) :: Maybe (Maybe a) where
+    type family Foo5 @a (a :: Maybe (Maybe a)) :: Maybe (Maybe a) where
       Foo5 ('Just ('Just (x :: a) :: Maybe a) :: Maybe (Maybe a)) = Apply JustSym0 (Apply JustSym0 (x :: a) :: Maybe a) :: Maybe (Maybe a)
     type Foo4 :: (a, b) -> (b, a)
-    type family Foo4 (a :: (a, b)) :: (b, a) where
-      Foo4 a_0123456789876543210 = Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210
+    type family Foo4 @a @b (a :: (a, b)) :: (b, a) where
+      Foo4 a_0123456789876543210 = Apply (LamCases_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210
     type Foo3 :: forall a. Maybe a -> a
-    type family Foo3 (a :: Maybe a) :: a where
-      Foo3 ('Just x) = x :: a
+    type family Foo3 @a (a :: Maybe a) :: a where
+      Foo3 @a ('Just x :: Maybe a) = x :: a
     type Foo2 :: forall a. Maybe a -> a
-    type family Foo2 (a :: Maybe a) :: a where
-      Foo2 ('Just x :: Maybe a) = x :: a
+    type family Foo2 @a (a :: Maybe a) :: a where
+      Foo2 @a ('Just x :: Maybe a :: Maybe a) = x :: a
     type Foo1 :: Maybe a -> a
-    type family Foo1 (a :: Maybe a) :: a where
+    type family Foo1 @a (a :: Maybe a) :: a where
       Foo1 ('Just x :: Maybe a) = x :: a
     type family G a where
-      G x = Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)
+      G x = Apply (LamCases_0123456789876543210Sym0 x) (Apply JustSym0 x)
     type family F3 a where
       F3 ('Just a :: Maybe Bool) = "hi"
     type family F2 a where
       F2 (x :: Maybe a) = x :: Maybe a
     type family F1 a where
       F1 (x :: Maybe Bool) = x :: Maybe Bool
-    sFoo9 :: forall a (t :: a). Sing t -> Sing (Apply Foo9Sym0 t :: a)
+    sFoo9 :: (forall (t :: a). Sing t -> Sing (Foo9 t :: a) :: Type)
     sFoo8 ::
-      forall a (t :: Maybe a). Sing t
-                               -> Sing (Apply Foo8Sym0 t :: Maybe a)
+      forall a (t :: Maybe a). Sing t -> Sing (Foo8 t :: Maybe a)
     sFoo7 ::
-      forall a b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: a)
+      (forall (t :: a) (t :: b).
+       Sing t -> Sing t -> Sing (Foo7 t t :: a) :: Type)
     sFoo6 ::
-      forall a (t :: Maybe (Maybe a)). Sing t
-                                       -> Sing (Apply Foo6Sym0 t :: Maybe (Maybe a))
+      (forall (t :: Maybe (Maybe a)).
+       Sing t -> Sing (Foo6 t :: Maybe (Maybe a)) :: Type)
     sFoo5 ::
-      forall a (t :: Maybe (Maybe a)). Sing t
-                                       -> Sing (Apply Foo5Sym0 t :: Maybe (Maybe a))
+      (forall (t :: Maybe (Maybe a)).
+       Sing t -> Sing (Foo5 t :: Maybe (Maybe a)) :: Type)
     sFoo4 ::
-      forall a b (t :: (a, b)). Sing t
-                                -> Sing (Apply Foo4Sym0 t :: (b, a))
-    sFoo3 ::
-      forall a (t :: Maybe a). Sing t -> Sing (Apply Foo3Sym0 t :: a)
-    sFoo2 ::
-      forall a (t :: Maybe a). Sing t -> Sing (Apply Foo2Sym0 t :: a)
+      (forall (t :: (a, b)). Sing t -> Sing (Foo4 t :: (b, a)) :: Type)
+    sFoo3 :: forall a (t :: Maybe a). Sing t -> Sing (Foo3 t :: a)
+    sFoo2 :: forall a (t :: Maybe a). Sing t -> Sing (Foo2 t :: a)
     sFoo1 ::
-      forall a (t :: Maybe a). Sing t -> Sing (Apply Foo1Sym0 t :: a)
-    sG :: forall arg. Sing arg -> Sing (Apply GSym0 arg)
-    sF3 :: forall arg. Sing arg -> Sing (Apply F3Sym0 arg)
-    sF2 :: forall arg. Sing arg -> Sing (Apply F2Sym0 arg)
-    sF1 :: forall arg. Sing arg -> Sing (Apply F1Sym0 arg)
+      (forall (t :: Maybe a). Sing t -> Sing (Foo1 t :: a) :: Type)
+    sG :: forall arg. Sing arg -> Sing (G arg)
+    sF3 :: forall arg. Sing arg -> Sing (F3 arg)
+    sF2 :: forall arg. Sing arg -> Sing (F2 arg)
+    sF1 :: forall arg. Sing arg -> Sing (F1 arg)
     sFoo9 (sX :: Sing x)
-      = case sX :: Sing x of
-          (_ :: Sing (x :: a))
-            -> let
-                 sG ::
-                   forall b (t :: a) (t :: b). Sing t
-                                               -> Sing t
-                                                  -> Sing (Apply (Apply (Let0123456789876543210GSym1 x) t) t :: a)
-                 sG (sY :: Sing y) _ = sY
-               in
-                 (applySing
-                    ((applySing ((singFun2 @(Let0123456789876543210GSym1 x)) sG)) sX))
-                   STuple0
+      = (\cases
+           (_ :: Sing (x :: a))
+             -> let
+                  sG ::
+                    (forall (t :: a) (t :: b).
+                     Sing t
+                     -> Sing t -> Sing (Let0123456789876543210G a x t t :: a) :: Type)
+                  sG (sY :: Sing y) _ = sY
+                in
+                  applySing
+                    (applySing (singFun2 @(Let0123456789876543210GSym0 a x) sG) sX)
+                    STuple0)
+          (sX :: Sing x)
     sFoo8
       (SJust (sWild_0123456789876543210 :: Sing wild_0123456789876543210))
-      = case
-            ((,) (sWild_0123456789876543210 :: Sing wild_0123456789876543210))
-              (SJust
-                 (sWild_0123456789876543210 :: Sing wild_0123456789876543210))
-        of
-          (,) (_ :: Sing (wild_0123456789876543210 :: a))
-              (_ :: Sing ('Just (wild_0123456789876543210 :: a) :: Maybe a))
-            -> let
-                 sX ::
-                   Sing @_ (Let0123456789876543210XSym1 wild_0123456789876543210)
-                 sX
-                   = (applySing ((singFun1 @JustSym0) SJust))
-                       (sWild_0123456789876543210 ::
-                          Sing (wild_0123456789876543210 :: a)) ::
-                       Sing (Apply JustSym0 (wild_0123456789876543210 :: a) :: Maybe a)
-               in sX
+      = (\cases
+           (_ :: Sing (wild_0123456789876543210 :: a))
+             (_ :: Sing ('Just (wild_0123456789876543210 :: a) :: Maybe a))
+             -> let
+                  sX :: Sing @_ (Let0123456789876543210X a wild_0123456789876543210)
+                  sX
+                    = applySing
+                        (singFun1 @JustSym0 SJust)
+                        (sWild_0123456789876543210 ::
+                           Sing (wild_0123456789876543210 :: a)) ::
+                        Sing (Apply JustSym0 (wild_0123456789876543210 :: a) :: Maybe a)
+                in sX)
+          (sWild_0123456789876543210 :: Sing wild_0123456789876543210)
+          (SJust
+             (sWild_0123456789876543210 :: Sing wild_0123456789876543210))
     sFoo8 SNothing
-      = case SNothing of
-          (_ :: Sing ('Nothing :: Maybe a))
-            -> let
-                 sX :: Sing @_ Let0123456789876543210XSym0
-                 sX = SNothing :: Sing (NothingSym0 :: Maybe a)
-               in sX
+      = (\cases
+           (_ :: Sing ('Nothing :: Maybe a))
+             -> let
+                  sX :: Sing @_ (Let0123456789876543210X a)
+                  sX = SNothing :: Sing (NothingSym0 :: Maybe a)
+                in sX)
+          SNothing
     sFoo7
       (sX :: Sing x)
       (sWild_0123456789876543210 :: Sing wild_0123456789876543210)
-      = case
-            ((,) (sX :: Sing x))
-              (sWild_0123456789876543210 :: Sing wild_0123456789876543210)
-        of
-          (,) (_ :: Sing (x :: a))
-              (_ :: Sing (wild_0123456789876543210 :: b))
-            -> sX :: Sing (x :: a)
+      = (\cases
+           (_ :: Sing (x :: a)) (_ :: Sing (wild_0123456789876543210 :: b))
+             -> sX :: Sing (x :: a))
+          (sX :: Sing x)
+          (sWild_0123456789876543210 :: Sing wild_0123456789876543210)
     sFoo6 (SJust (sX :: Sing x))
-      = case SJust (sX :: Sing x) of
-          (_ :: Sing ('Just x :: Maybe (Maybe a)))
-            -> let
-                 sScrutinee_0123456789876543210 ::
-                   Sing @_ (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)
-                 sScrutinee_0123456789876543210 = sX :: Sing (x :: Maybe a)
-               in
-                 (id
-                    @(Sing (Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x) :: Maybe (Maybe a))))
-                   (case sScrutinee_0123456789876543210 of
-                      SJust (sY :: Sing y)
-                        -> case ((,) (sY :: Sing y)) (SJust (sY :: Sing y)) of
-                             (,) (_ :: Sing (y :: a)) (_ :: Sing ('Just (y :: a) :: Maybe a))
-                               -> (applySing ((singFun1 @JustSym0) SJust))
-                                    ((applySing ((singFun1 @JustSym0) SJust))
-                                       (sY :: Sing (y :: a)) ::
-                                       Sing (Apply JustSym0 (y :: a) :: Maybe a)))
+      = (\cases
+           (_ :: Sing ('Just x :: Maybe (Maybe a)))
+             -> applySing
+                  (singFun1
+                     @(LamCases_0123456789876543210Sym0 a x)
+                     (\cases
+                        (SJust (sY :: Sing y))
+                          -> (\cases
+                                (_ :: Sing (y :: a)) (_ :: Sing ('Just (y :: a) :: Maybe a))
+                                  -> applySing
+                                       (singFun1 @JustSym0 SJust)
+                                       (applySing
+                                          (singFun1 @JustSym0 SJust) (sY :: Sing (y :: a)) ::
+                                          Sing (Apply JustSym0 (y :: a) :: Maybe a)))
+                               (sY :: Sing y) (SJust (sY :: Sing y))))
+                  (sX :: Sing (x :: Maybe a)))
+          (SJust (sX :: Sing x))
     sFoo5 (SJust (SJust (sX :: Sing x)))
-      = case
-            (((,,) (sX :: Sing x)) (SJust (sX :: Sing x)))
-              (SJust (SJust (sX :: Sing x)))
-        of
-          (,,) (_ :: Sing (x :: a)) (_ :: Sing ('Just (x :: a) :: Maybe a))
-               (_ :: Sing ('Just ('Just (x :: a) :: Maybe a) :: Maybe (Maybe a)))
-            -> (applySing ((singFun1 @JustSym0) SJust))
-                 ((applySing ((singFun1 @JustSym0) SJust)) (sX :: Sing (x :: a)) ::
-                    Sing (Apply JustSym0 (x :: a) :: Maybe a)) ::
-                 Sing (Apply JustSym0 (Apply JustSym0 (x :: a) :: Maybe a) :: Maybe (Maybe a))
+      = (\cases
+           (_ :: Sing (x :: a))
+             (_ :: Sing ('Just (x :: a) :: Maybe a))
+             (_ :: Sing ('Just ('Just (x :: a) :: Maybe a) :: Maybe (Maybe a)))
+             -> applySing
+                  (singFun1 @JustSym0 SJust)
+                  (applySing (singFun1 @JustSym0 SJust) (sX :: Sing (x :: a)) ::
+                     Sing (Apply JustSym0 (x :: a) :: Maybe a)) ::
+                  Sing (Apply JustSym0 (Apply JustSym0 (x :: a) :: Maybe a) :: Maybe (Maybe a)))
+          (sX :: Sing x) (SJust (sX :: Sing x))
+          (SJust (SJust (sX :: Sing x)))
     sFoo4 (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing
-           ((singFun1
-               @(Apply Lambda_0123456789876543210Sym0 a_0123456789876543210))
-              (\ sArg_0123456789876543210
-                 -> case sArg_0123456789876543210 of
-                      (_ :: Sing arg_0123456789876543210)
-                        -> (id
-                              @(Sing (Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 arg_0123456789876543210)))
-                             (case sArg_0123456789876543210 of
-                                STuple2 (sX :: Sing x) (sY :: Sing y)
-                                  -> case ((,) (sX :: Sing x)) (sY :: Sing y) of
-                                       (,) (_ :: Sing (x :: a)) (_ :: Sing (y :: b))
-                                         -> (applySing
-                                               ((applySing ((singFun2 @Tuple2Sym0) STuple2))
-                                                  (sY :: Sing (y :: b))))
-                                              (sX :: Sing (x :: a))))))
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 a_0123456789876543210)
+             (\cases
+                (STuple2 (sX :: Sing x) (sY :: Sing y))
+                  -> (\cases
+                        (_ :: Sing (x :: a)) (_ :: Sing (y :: b))
+                          -> applySing
+                               (applySing (singFun2 @Tuple2Sym0 STuple2) (sY :: Sing (y :: b)))
+                               (sX :: Sing (x :: a)))
+                       (sX :: Sing x) (sY :: Sing y)))
           sA_0123456789876543210
     sFoo3 (SJust (sX :: Sing x)) = sX :: Sing (x :: a)
     sFoo2 (SJust (sX :: Sing x))
-      = case SJust (sX :: Sing x) of
-          (_ :: Sing ('Just x :: Maybe a)) -> sX :: Sing (x :: a)
+      = (\cases (_ :: Sing ('Just x :: Maybe a)) -> sX :: Sing (x :: a))
+          (SJust (sX :: Sing x))
     sFoo1 (SJust (sX :: Sing x))
-      = case SJust (sX :: Sing x) of
-          (_ :: Sing ('Just x :: Maybe a)) -> sX :: Sing (x :: a)
+      = (\cases (_ :: Sing ('Just x :: Maybe a)) -> sX :: Sing (x :: a))
+          (SJust (sX :: Sing x))
     sG (sX :: Sing x)
-      = let
-          sScrutinee_0123456789876543210 ::
-            Sing @_ (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)
-          sScrutinee_0123456789876543210
-            = (applySing ((singFun1 @JustSym0) SJust)) sX
-        in
-          (id
-             @(Sing (Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x))))
-            (case sScrutinee_0123456789876543210 of
-               SJust (sY :: Sing y)
-                 -> case SJust (sY :: Sing y) of
-                      (_ :: Sing ('Just y :: Maybe Bool)) -> sY :: Sing (y :: Bool))
+      = applySing
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 x)
+             (\cases
+                (SJust (sY :: Sing y))
+                  -> (\cases
+                        (_ :: Sing ('Just y :: Maybe Bool)) -> sY :: Sing (y :: Bool))
+                       (SJust (sY :: Sing y))))
+          (applySing (singFun1 @JustSym0 SJust) sX)
     sF3 (SJust (sA :: Sing a))
-      = case SJust (sA :: Sing a) of
-          (_ :: Sing ('Just a :: Maybe Bool)) -> sing :: Sing "hi"
+      = (\cases (_ :: Sing ('Just a :: Maybe Bool)) -> sing :: Sing "hi")
+          (SJust (sA :: Sing a))
     sF2 (sX :: Sing x)
-      = case sX :: Sing x of
-          (_ :: Sing (x :: Maybe a)) -> sX :: Sing (x :: Maybe a)
+      = (\cases (_ :: Sing (x :: Maybe a)) -> sX :: Sing (x :: Maybe a))
+          (sX :: Sing x)
     sF1 (sX :: Sing x)
-      = case sX :: Sing x of
-          (_ :: Sing (x :: Maybe Bool)) -> sX :: Sing (x :: Maybe Bool)
+      = (\cases
+           (_ :: Sing (x :: Maybe Bool)) -> sX :: Sing (x :: Maybe Bool))
+          (sX :: Sing x)
     instance SingI (Foo9Sym0 :: (~>) a a) where
-      sing = (singFun1 @Foo9Sym0) sFoo9
+      sing = singFun1 @Foo9Sym0 sFoo9
     instance SingI (Foo8Sym0 :: (~>) (Maybe a) (Maybe a)) where
-      sing = (singFun1 @Foo8Sym0) sFoo8
+      sing = singFun1 @Foo8Sym0 sFoo8
     instance SingI (Foo7Sym0 :: (~>) a ((~>) b a)) where
-      sing = (singFun2 @Foo7Sym0) sFoo7
+      sing = singFun2 @Foo7Sym0 sFoo7
     instance SingI d => SingI (Foo7Sym1 (d :: a) :: (~>) b a) where
-      sing = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 (sing @d))
+      sing = singFun1 @(Foo7Sym1 (d :: a)) (sFoo7 (sing @d))
     instance SingI1 (Foo7Sym1 :: a -> (~>) b a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 s)
+        = singFun1 @(Foo7Sym1 (d :: a)) (sFoo7 s)
     instance SingI (Foo6Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))) where
-      sing = (singFun1 @Foo6Sym0) sFoo6
+      sing = singFun1 @Foo6Sym0 sFoo6
     instance SingI (Foo5Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))) where
-      sing = (singFun1 @Foo5Sym0) sFoo5
+      sing = singFun1 @Foo5Sym0 sFoo5
     instance SingI (Foo4Sym0 :: (~>) (a, b) (b, a)) where
-      sing = (singFun1 @Foo4Sym0) sFoo4
+      sing = singFun1 @Foo4Sym0 sFoo4
     instance SingI (Foo3Sym0 :: (~>) (Maybe a) a) where
-      sing = (singFun1 @Foo3Sym0) sFoo3
+      sing = singFun1 @Foo3Sym0 sFoo3
     instance SingI (Foo2Sym0 :: (~>) (Maybe a) a) where
-      sing = (singFun1 @Foo2Sym0) sFoo2
+      sing = singFun1 @Foo2Sym0 sFoo2
     instance SingI (Foo1Sym0 :: (~>) (Maybe a) a) where
-      sing = (singFun1 @Foo1Sym0) sFoo1
+      sing = singFun1 @Foo1Sym0 sFoo1
     instance SingI GSym0 where
-      sing = (singFun1 @GSym0) sG
+      sing = singFun1 @GSym0 sG
     instance SingI F3Sym0 where
-      sing = (singFun1 @F3Sym0) sF3
+      sing = singFun1 @F3Sym0 sF3
     instance SingI F2Sym0 where
-      sing = (singFun1 @F2Sym0) sF2
+      sing = singFun1 @F2Sym0 sF2
     instance SingI F1Sym0 where
-      sing = (singFun1 @F1Sym0) sF1
+      sing = singFun1 @F1Sym0 sF1
diff --git a/tests/compile-and-dump/Singletons/T184.golden b/tests/compile-and-dump/Singletons/T184.golden
--- a/tests/compile-and-dump/Singletons/T184.golden
+++ b/tests/compile-and-dump/Singletons/T184.golden
@@ -25,249 +25,111 @@
     cartProd xs ys = [(x, y) | x <- xs, y <- ys]
     trues :: [Bool] -> [Bool]
     trues xs = [x | x <- xs, x]
-    type family Lambda_0123456789876543210 xs x where
-      Lambda_0123456789876543210 xs x = Apply (Apply (>>@#@$) (Apply GuardSym0 x)) (Apply ReturnSym0 x)
-    data Lambda_0123456789876543210Sym0 xs0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 xs0123456789876543210 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) arg) (Lambda_0123456789876543210Sym2 xs0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 xs0123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    type family Lambda_0123456789876543210Sym2 xs0123456789876543210 x0123456789876543210 where
-      Lambda_0123456789876543210Sym2 xs0123456789876543210 x0123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 x0123456789876543210
-    type family Lambda_0123456789876543210 x xs ys y where
-      Lambda_0123456789876543210 x xs ys y = Apply ReturnSym0 (Apply (Apply Tuple2Sym0 x) y)
-    data Lambda_0123456789876543210Sym0 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 x0123456789876543210 xs0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 xs0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) xs0123456789876543210 = Lambda_0123456789876543210Sym2 x0123456789876543210 xs0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 x0123456789876543210 xs0123456789876543210 ys0123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 xs0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 xs0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 xs0123456789876543210 ys0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 xs0123456789876543210) ys0123456789876543210 = Lambda_0123456789876543210Sym3 x0123456789876543210 xs0123456789876543210 ys0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 xs0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 y0123456789876543210
-      where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym4 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 y0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 xs0123456789876543210 ys0123456789876543210) y0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 y0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 x0123456789876543210 xs0123456789876543210 ys0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    type family Lambda_0123456789876543210Sym4 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 y0123456789876543210 where
-      Lambda_0123456789876543210Sym4 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 y0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 y0123456789876543210
-    type family Lambda_0123456789876543210 xs ys x where
-      Lambda_0123456789876543210 xs ys x = Apply (Apply (>>=@#@$) ys) (Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) xs) ys)
-    data Lambda_0123456789876543210Sym0 xs0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) arg) (Lambda_0123456789876543210Sym2 xs0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) ys0123456789876543210 = Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 x0123456789876543210 where
-      Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 x0123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 x0123456789876543210
-    type family Lambda_0123456789876543210 xs ys x where
-      Lambda_0123456789876543210 xs ys x = Apply ReturnSym0 x
-    data Lambda_0123456789876543210Sym0 xs0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) arg) (Lambda_0123456789876543210Sym2 xs0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) ys0123456789876543210 = Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 x0123456789876543210 where
-      Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 x0123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 x0123456789876543210
-    type family Lambda_0123456789876543210 xs ys y where
-      Lambda_0123456789876543210 xs ys y = Apply ReturnSym0 y
-    data Lambda_0123456789876543210Sym0 xs0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) arg) (Lambda_0123456789876543210Sym2 xs0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) ys0123456789876543210 = Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 y0123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 y0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) y0123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 y0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 y0123456789876543210 where
-      Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 y0123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 y0123456789876543210
-    type family Case_0123456789876543210 arg_0123456789876543210 xs ys t where
-      Case_0123456789876543210 arg_0123456789876543210 xs ys '(x,
-                                                               y) = Apply ReturnSym0 (Apply (Apply Tuple2Sym0 x) y)
-    type family Lambda_0123456789876543210 xs ys arg_0123456789876543210 where
-      Lambda_0123456789876543210 xs ys arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 xs ys arg_0123456789876543210
-    data Lambda_0123456789876543210Sym0 xs0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) arg) (Lambda_0123456789876543210Sym2 xs0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) ys0123456789876543210 = Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 arg_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (xs0123456789876543210 :: [Bool]) a_0123456789876543210 where
+      LamCases_0123456789876543210 xs x = Apply (Apply (>>@#@$) (Apply GuardSym0 x)) (Apply ReturnSym0 x)
+    data LamCases_0123456789876543210Sym0 (xs0123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 arg_01234567898765432100123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 arg_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 xs0123456789876543210) arg) (LamCases_0123456789876543210Sym1 xs0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 xs0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 xs0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 xs0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 xs0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg_01234567898765432100123456789876543210 where
-      Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg_01234567898765432100123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 arg_01234567898765432100123456789876543210
-    type family Lambda_0123456789876543210 a ma mb b where
-      Lambda_0123456789876543210 a ma mb b = Apply (Apply (>>@#@$) (Apply GuardSym0 b)) (Apply ReturnSym0 a)
-    data Lambda_0123456789876543210Sym0 a0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (xs0123456789876543210 :: [Bool]) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 xs0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 xs0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 x0123456789876543210 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_0123456789876543210 where
+      LamCases_0123456789876543210 x xs ys y = Apply ReturnSym0 (Apply (Apply Tuple2Sym0 x) y)
+    data LamCases_0123456789876543210Sym0 x0123456789876543210 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 a0123456789876543210 = Lambda_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 x0123456789876543210 xs0123456789876543210 ys0123456789876543210) arg) (LamCases_0123456789876543210Sym1 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 x0123456789876543210 xs0123456789876543210 ys0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 x0123456789876543210 xs0123456789876543210 ys0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 a0123456789876543210 ma0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 x0123456789876543210 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_0123456789876543210 where
+      LamCases_0123456789876543210 xs ys x = Apply (Apply (>>=@#@$) ys) (LamCases_0123456789876543210Sym0 x xs ys)
+    data LamCases_0123456789876543210Sym0 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 a0123456789876543210) arg) (Lambda_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 a0123456789876543210 ma0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 a0123456789876543210) ma0123456789876543210 = Lambda_0123456789876543210Sym2 a0123456789876543210 ma0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) arg) (LamCases_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 a0123456789876543210 ma0123456789876543210 mb0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_0123456789876543210 where
+      LamCases_0123456789876543210 xs ys x = Apply ReturnSym0 x
+    data LamCases_0123456789876543210Sym0 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 ma0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a0123456789876543210 ma0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 a0123456789876543210 ma0123456789876543210 mb0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 ma0123456789876543210) mb0123456789876543210 = Lambda_0123456789876543210Sym3 a0123456789876543210 ma0123456789876543210 mb0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a0123456789876543210 ma0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) arg) (LamCases_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    data Lambda_0123456789876543210Sym3 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 b0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_0123456789876543210 where
+      LamCases_0123456789876543210 xs ys y = Apply ReturnSym0 y
+    data LamCases_0123456789876543210Sym0 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym3KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym3 a0123456789876543210 ma0123456789876543210 mb0123456789876543210) arg) (Lambda_0123456789876543210Sym4 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym3 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 b0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym3 a0123456789876543210 ma0123456789876543210 mb0123456789876543210) b0123456789876543210 = Lambda_0123456789876543210 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 b0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a0123456789876543210 ma0123456789876543210 mb0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) arg) (LamCases_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())
-    type family Lambda_0123456789876543210Sym4 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 b0123456789876543210 where
-      Lambda_0123456789876543210Sym4 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 b0123456789876543210 = Lambda_0123456789876543210 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 b0123456789876543210
-    type family Lambda_0123456789876543210 ma mb a where
-      Lambda_0123456789876543210 ma mb a = Apply (Apply (>>=@#@$) mb) (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) ma) mb)
-    data Lambda_0123456789876543210Sym0 ma0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_0123456789876543210 where
+      LamCases_0123456789876543210 xs ys '(x,
+                                           y) = Apply ReturnSym0 (Apply (Apply Tuple2Sym0 x) y)
+    data LamCases_0123456789876543210Sym0 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 ma0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 ma0123456789876543210 = Lambda_0123456789876543210Sym1 ma0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) arg) (LamCases_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 xs0123456789876543210 ys0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 ma0123456789876543210 mb0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (xs0123456789876543210 :: [a0123456789876543210]) (ys0123456789876543210 :: [b0123456789876543210]) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 xs0123456789876543210 ys0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a0123456789876543210 (ma0123456789876543210 :: Maybe a0123456789876543210) (mb0123456789876543210 :: Maybe Bool) a_0123456789876543210 where
+      LamCases_0123456789876543210 a ma mb b = Apply (Apply (>>@#@$) (Apply GuardSym0 b)) (Apply ReturnSym0 a)
+    data LamCases_0123456789876543210Sym0 a0123456789876543210 (ma0123456789876543210 :: Maybe a0123456789876543210) (mb0123456789876543210 :: Maybe Bool) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 ma0123456789876543210) arg) (Lambda_0123456789876543210Sym2 ma0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 ma0123456789876543210 mb0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 ma0123456789876543210) mb0123456789876543210 = Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 ma0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 ma0123456789876543210 mb0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 ma0123456789876543210 mb0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 ma0123456789876543210 mb0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210 a0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a0123456789876543210 (ma0123456789876543210 :: Maybe a0123456789876543210) (mb0123456789876543210 :: Maybe Bool) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (ma0123456789876543210 :: Maybe a0123456789876543210) (mb0123456789876543210 :: Maybe Bool) a_0123456789876543210 where
+      LamCases_0123456789876543210 ma mb a = Apply (Apply (>>=@#@$) mb) (LamCases_0123456789876543210Sym0 a ma mb)
+    data LamCases_0123456789876543210Sym0 (ma0123456789876543210 :: Maybe a0123456789876543210) (mb0123456789876543210 :: Maybe Bool) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210) arg) (Lambda_0123456789876543210Sym3 ma0123456789876543210 mb0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210 a0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210) a0123456789876543210 = Lambda_0123456789876543210 ma0123456789876543210 mb0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 ma0123456789876543210 mb0123456789876543210) arg) (LamCases_0123456789876543210Sym1 ma0123456789876543210 mb0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 ma0123456789876543210 mb0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 ma0123456789876543210 mb0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 ma0123456789876543210 mb0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 ma0123456789876543210 mb0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 ma0123456789876543210 mb0123456789876543210 a0123456789876543210 where
-      Lambda_0123456789876543210Sym3 ma0123456789876543210 mb0123456789876543210 a0123456789876543210 = Lambda_0123456789876543210 ma0123456789876543210 mb0123456789876543210 a0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (ma0123456789876543210 :: Maybe a0123456789876543210) (mb0123456789876543210 :: Maybe Bool) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 ma0123456789876543210 mb0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 ma0123456789876543210 mb0123456789876543210 a_01234567898765432100123456789876543210
     type TruesSym0 :: (~>) [Bool] [Bool]
     data TruesSym0 :: (~>) [Bool] [Bool]
       where
         TruesSym0KindInference :: SameKind (Apply TruesSym0 arg) (TruesSym1 arg) =>
                                   TruesSym0 a0123456789876543210
-    type instance Apply TruesSym0 a0123456789876543210 = Trues a0123456789876543210
+    type instance Apply @[Bool] @[Bool] TruesSym0 a0123456789876543210 = Trues a0123456789876543210
     instance SuppressUnusedWarnings TruesSym0 where
-      suppressUnusedWarnings = snd (((,) TruesSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) TruesSym0KindInference ())
     type TruesSym1 :: [Bool] -> [Bool]
     type family TruesSym1 (a0123456789876543210 :: [Bool]) :: [Bool] where
       TruesSym1 a0123456789876543210 = Trues a0123456789876543210
@@ -276,180 +138,184 @@
       where
         CartProdSym0KindInference :: SameKind (Apply CartProdSym0 arg) (CartProdSym1 arg) =>
                                      CartProdSym0 a0123456789876543210
-    type instance Apply CartProdSym0 a0123456789876543210 = CartProdSym1 a0123456789876543210
+    type instance Apply @[a] @((~>) [b] [(a,
+                                          b)]) CartProdSym0 a0123456789876543210 = CartProdSym1 a0123456789876543210
     instance SuppressUnusedWarnings CartProdSym0 where
-      suppressUnusedWarnings = snd (((,) CartProdSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) CartProdSym0KindInference ())
     type CartProdSym1 :: [a] -> (~>) [b] [(a, b)]
     data CartProdSym1 (a0123456789876543210 :: [a]) :: (~>) [b] [(a,
                                                                   b)]
       where
         CartProdSym1KindInference :: SameKind (Apply (CartProdSym1 a0123456789876543210) arg) (CartProdSym2 a0123456789876543210 arg) =>
                                      CartProdSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (CartProdSym1 a0123456789876543210) a0123456789876543210 = CartProd a0123456789876543210 a0123456789876543210
+    type instance Apply @[b] @[(a,
+                                b)] (CartProdSym1 a0123456789876543210) a0123456789876543210 = CartProd a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (CartProdSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) CartProdSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) CartProdSym1KindInference ())
     type CartProdSym2 :: [a] -> [b] -> [(a, b)]
-    type family CartProdSym2 (a0123456789876543210 :: [a]) (a0123456789876543210 :: [b]) :: [(a,
-                                                                                              b)] where
+    type family CartProdSym2 @a @b (a0123456789876543210 :: [a]) (a0123456789876543210 :: [b]) :: [(a,
+                                                                                                    b)] where
       CartProdSym2 a0123456789876543210 a0123456789876543210 = CartProd a0123456789876543210 a0123456789876543210
     type Zip'Sym0 :: (~>) [a] ((~>) [b] [(a, b)])
     data Zip'Sym0 :: (~>) [a] ((~>) [b] [(a, b)])
       where
         Zip'Sym0KindInference :: SameKind (Apply Zip'Sym0 arg) (Zip'Sym1 arg) =>
                                  Zip'Sym0 a0123456789876543210
-    type instance Apply Zip'Sym0 a0123456789876543210 = Zip'Sym1 a0123456789876543210
+    type instance Apply @[a] @((~>) [b] [(a,
+                                          b)]) Zip'Sym0 a0123456789876543210 = Zip'Sym1 a0123456789876543210
     instance SuppressUnusedWarnings Zip'Sym0 where
-      suppressUnusedWarnings = snd (((,) Zip'Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Zip'Sym0KindInference ())
     type Zip'Sym1 :: [a] -> (~>) [b] [(a, b)]
     data Zip'Sym1 (a0123456789876543210 :: [a]) :: (~>) [b] [(a, b)]
       where
         Zip'Sym1KindInference :: SameKind (Apply (Zip'Sym1 a0123456789876543210) arg) (Zip'Sym2 a0123456789876543210 arg) =>
                                  Zip'Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Zip'Sym1 a0123456789876543210) a0123456789876543210 = Zip' a0123456789876543210 a0123456789876543210
+    type instance Apply @[b] @[(a,
+                                b)] (Zip'Sym1 a0123456789876543210) a0123456789876543210 = Zip' a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (Zip'Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) Zip'Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) Zip'Sym1KindInference ())
     type Zip'Sym2 :: [a] -> [b] -> [(a, b)]
-    type family Zip'Sym2 (a0123456789876543210 :: [a]) (a0123456789876543210 :: [b]) :: [(a,
-                                                                                          b)] where
+    type family Zip'Sym2 @a @b (a0123456789876543210 :: [a]) (a0123456789876543210 :: [b]) :: [(a,
+                                                                                                b)] where
       Zip'Sym2 a0123456789876543210 a0123456789876543210 = Zip' a0123456789876543210 a0123456789876543210
     type BoogieSym0 :: (~>) (Maybe a) ((~>) (Maybe Bool) (Maybe a))
     data BoogieSym0 :: (~>) (Maybe a) ((~>) (Maybe Bool) (Maybe a))
       where
         BoogieSym0KindInference :: SameKind (Apply BoogieSym0 arg) (BoogieSym1 arg) =>
                                    BoogieSym0 a0123456789876543210
-    type instance Apply BoogieSym0 a0123456789876543210 = BoogieSym1 a0123456789876543210
+    type instance Apply @(Maybe a) @((~>) (Maybe Bool) (Maybe a)) BoogieSym0 a0123456789876543210 = BoogieSym1 a0123456789876543210
     instance SuppressUnusedWarnings BoogieSym0 where
-      suppressUnusedWarnings = snd (((,) BoogieSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BoogieSym0KindInference ())
     type BoogieSym1 :: Maybe a -> (~>) (Maybe Bool) (Maybe a)
     data BoogieSym1 (a0123456789876543210 :: Maybe a) :: (~>) (Maybe Bool) (Maybe a)
       where
         BoogieSym1KindInference :: SameKind (Apply (BoogieSym1 a0123456789876543210) arg) (BoogieSym2 a0123456789876543210 arg) =>
                                    BoogieSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (BoogieSym1 a0123456789876543210) a0123456789876543210 = Boogie a0123456789876543210 a0123456789876543210
+    type instance Apply @(Maybe Bool) @(Maybe a) (BoogieSym1 a0123456789876543210) a0123456789876543210 = Boogie a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (BoogieSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BoogieSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) BoogieSym1KindInference ())
     type BoogieSym2 :: Maybe a -> Maybe Bool -> Maybe a
-    type family BoogieSym2 (a0123456789876543210 :: Maybe a) (a0123456789876543210 :: Maybe Bool) :: Maybe a where
+    type family BoogieSym2 @a (a0123456789876543210 :: Maybe a) (a0123456789876543210 :: Maybe Bool) :: Maybe a where
       BoogieSym2 a0123456789876543210 a0123456789876543210 = Boogie a0123456789876543210 a0123456789876543210
     type Trues :: [Bool] -> [Bool]
     type family Trues (a :: [Bool]) :: [Bool] where
-      Trues xs = Apply (Apply (>>=@#@$) xs) (Apply Lambda_0123456789876543210Sym0 xs)
+      Trues xs = Apply (Apply (>>=@#@$) xs) (LamCases_0123456789876543210Sym0 xs)
     type CartProd :: [a] -> [b] -> [(a, b)]
-    type family CartProd (a :: [a]) (a :: [b]) :: [(a, b)] where
-      CartProd xs ys = Apply (Apply (>>=@#@$) xs) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)
+    type family CartProd @a @b (a :: [a]) (a :: [b]) :: [(a, b)] where
+      CartProd xs ys = Apply (Apply (>>=@#@$) xs) (LamCases_0123456789876543210Sym0 xs ys)
     type Zip' :: [a] -> [b] -> [(a, b)]
-    type family Zip' (a :: [a]) (a :: [b]) :: [(a, b)] where
-      Zip' xs ys = Apply (Apply (>>=@#@$) (Apply (Apply MzipSym0 (Apply (Apply (>>=@#@$) xs) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))) (Apply (Apply (>>=@#@$) ys) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)))) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)
+    type family Zip' @a @b (a :: [a]) (a :: [b]) :: [(a, b)] where
+      Zip' xs ys = Apply (Apply (>>=@#@$) (Apply (Apply MzipSym0 (Apply (Apply (>>=@#@$) xs) (LamCases_0123456789876543210Sym0 xs ys))) (Apply (Apply (>>=@#@$) ys) (LamCases_0123456789876543210Sym0 xs ys)))) (LamCases_0123456789876543210Sym0 xs ys)
     type Boogie :: Maybe a -> Maybe Bool -> Maybe a
-    type family Boogie (a :: Maybe a) (a :: Maybe Bool) :: Maybe a where
-      Boogie ma mb = Apply (Apply (>>=@#@$) ma) (Apply (Apply Lambda_0123456789876543210Sym0 ma) mb)
+    type family Boogie @a (a :: Maybe a) (a :: Maybe Bool) :: Maybe a where
+      Boogie ma mb = Apply (Apply (>>=@#@$) ma) (LamCases_0123456789876543210Sym0 ma mb)
     sTrues ::
-      forall (t :: [Bool]). Sing t -> Sing (Apply TruesSym0 t :: [Bool])
+      (forall (t :: [Bool]). Sing t -> Sing (Trues t :: [Bool]) :: Type)
     sCartProd ::
-      forall a b (t :: [a]) (t :: [b]). Sing t
-                                        -> Sing t
-                                           -> Sing (Apply (Apply CartProdSym0 t) t :: [(a, b)])
+      (forall (t :: [a]) (t :: [b]).
+       Sing t -> Sing t -> Sing (CartProd t t :: [(a, b)]) :: Type)
     sZip' ::
-      forall a b (t :: [a]) (t :: [b]). Sing t
-                                        -> Sing t -> Sing (Apply (Apply Zip'Sym0 t) t :: [(a, b)])
+      (forall (t :: [a]) (t :: [b]).
+       Sing t -> Sing t -> Sing (Zip' t t :: [(a, b)]) :: Type)
     sBoogie ::
-      forall a (t :: Maybe a) (t :: Maybe Bool). Sing t
-                                                 -> Sing t
-                                                    -> Sing (Apply (Apply BoogieSym0 t) t :: Maybe a)
+      (forall (t :: Maybe a) (t :: Maybe Bool).
+       Sing t -> Sing t -> Sing (Boogie t t :: Maybe a) :: Type)
     sTrues (sXs :: Sing xs)
-      = (applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sXs))
-          ((singFun1 @(Apply Lambda_0123456789876543210Sym0 xs))
-             (\ sX
-                -> case sX of
-                     (_ :: Sing x)
-                       -> (applySing
-                             ((applySing ((singFun2 @(>>@#@$)) (%>>)))
-                                ((applySing ((singFun1 @GuardSym0) sGuard)) sX)))
-                            ((applySing ((singFun1 @ReturnSym0) sReturn)) sX)))
+      = applySing
+          (applySing (singFun2 @(>>=@#@$) (%>>=)) sXs)
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 xs)
+             (\cases
+                (sX :: Sing x)
+                  -> applySing
+                       (applySing
+                          (singFun2 @(>>@#@$) (%>>))
+                          (applySing (singFun1 @GuardSym0 sGuard) sX))
+                       (applySing (singFun1 @ReturnSym0 sReturn) sX)))
     sCartProd (sXs :: Sing xs) (sYs :: Sing ys)
-      = (applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sXs))
-          ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))
-             (\ sX
-                -> case sX of
-                     (_ :: Sing x)
-                       -> (applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sYs))
-                            ((singFun1
-                                @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) xs) ys))
-                               (\ sY
-                                  -> case sY of
-                                       (_ :: Sing y)
-                                         -> (applySing ((singFun1 @ReturnSym0) sReturn))
-                                              ((applySing
-                                                  ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX))
-                                                 sY)))))
+      = applySing
+          (applySing (singFun2 @(>>=@#@$) (%>>=)) sXs)
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 xs ys)
+             (\cases
+                (sX :: Sing x)
+                  -> applySing
+                       (applySing (singFun2 @(>>=@#@$) (%>>=)) sYs)
+                       (singFun1
+                          @(LamCases_0123456789876543210Sym0 x xs ys)
+                          (\cases
+                             (sY :: Sing y)
+                               -> applySing
+                                    (singFun1 @ReturnSym0 sReturn)
+                                    (applySing (applySing (singFun2 @Tuple2Sym0 STuple2) sX) sY)))))
     sZip' (sXs :: Sing xs) (sYs :: Sing ys)
-      = (applySing
-           ((applySing ((singFun2 @(>>=@#@$)) (%>>=)))
-              ((applySing
-                  ((applySing ((singFun2 @MzipSym0) sMzip))
-                     ((applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sXs))
-                        ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))
-                           (\ sX
-                              -> case sX of
-                                   (_ :: Sing x)
-                                     -> (applySing ((singFun1 @ReturnSym0) sReturn)) sX)))))
-                 ((applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sYs))
-                    ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))
-                       (\ sY
-                          -> case sY of
-                               (_ :: Sing y)
-                                 -> (applySing ((singFun1 @ReturnSym0) sReturn)) sY))))))
-          ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))
-             (\ sArg_0123456789876543210
-                -> case sArg_0123456789876543210 of
-                     (_ :: Sing arg_0123456789876543210)
-                       -> (id
-                             @(Sing (Case_0123456789876543210 arg_0123456789876543210 xs ys arg_0123456789876543210)))
-                            (case sArg_0123456789876543210 of
-                               STuple2 (sX :: Sing x) (sY :: Sing y)
-                                 -> (applySing ((singFun1 @ReturnSym0) sReturn))
-                                      ((applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX))
-                                         sY))))
+      = applySing
+          (applySing
+             (singFun2 @(>>=@#@$) (%>>=))
+             (applySing
+                (applySing
+                   (singFun2 @MzipSym0 sMzip)
+                   (applySing
+                      (applySing (singFun2 @(>>=@#@$) (%>>=)) sXs)
+                      (singFun1
+                         @(LamCases_0123456789876543210Sym0 xs ys)
+                         (\cases
+                            (sX :: Sing x) -> applySing (singFun1 @ReturnSym0 sReturn) sX))))
+                (applySing
+                   (applySing (singFun2 @(>>=@#@$) (%>>=)) sYs)
+                   (singFun1
+                      @(LamCases_0123456789876543210Sym0 xs ys)
+                      (\cases
+                         (sY :: Sing y) -> applySing (singFun1 @ReturnSym0 sReturn) sY)))))
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 xs ys)
+             (\cases
+                (STuple2 (sX :: Sing x) (sY :: Sing y))
+                  -> applySing
+                       (singFun1 @ReturnSym0 sReturn)
+                       (applySing (applySing (singFun2 @Tuple2Sym0 STuple2) sX) sY)))
     sBoogie (sMa :: Sing ma) (sMb :: Sing mb)
-      = (applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sMa))
-          ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 ma) mb))
-             (\ sA
-                -> case sA of
-                     (_ :: Sing a)
-                       -> (applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sMb))
-                            ((singFun1
-                                @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) ma) mb))
-                               (\ sB
-                                  -> case sB of
-                                       (_ :: Sing b)
-                                         -> (applySing
-                                               ((applySing ((singFun2 @(>>@#@$)) (%>>)))
-                                                  ((applySing ((singFun1 @GuardSym0) sGuard)) sB)))
-                                              ((applySing ((singFun1 @ReturnSym0) sReturn)) sA)))))
+      = applySing
+          (applySing (singFun2 @(>>=@#@$) (%>>=)) sMa)
+          (singFun1
+             @(LamCases_0123456789876543210Sym0 ma mb)
+             (\cases
+                (sA :: Sing a)
+                  -> applySing
+                       (applySing (singFun2 @(>>=@#@$) (%>>=)) sMb)
+                       (singFun1
+                          @(LamCases_0123456789876543210Sym0 a ma mb)
+                          (\cases
+                             (sB :: Sing b)
+                               -> applySing
+                                    (applySing
+                                       (singFun2 @(>>@#@$) (%>>))
+                                       (applySing (singFun1 @GuardSym0 sGuard) sB))
+                                    (applySing (singFun1 @ReturnSym0 sReturn) sA)))))
     instance SingI (TruesSym0 :: (~>) [Bool] [Bool]) where
-      sing = (singFun1 @TruesSym0) sTrues
+      sing = singFun1 @TruesSym0 sTrues
     instance SingI (CartProdSym0 :: (~>) [a] ((~>) [b] [(a, b)])) where
-      sing = (singFun2 @CartProdSym0) sCartProd
+      sing = singFun2 @CartProdSym0 sCartProd
     instance SingI d =>
              SingI (CartProdSym1 (d :: [a]) :: (~>) [b] [(a, b)]) where
-      sing = (singFun1 @(CartProdSym1 (d :: [a]))) (sCartProd (sing @d))
+      sing = singFun1 @(CartProdSym1 (d :: [a])) (sCartProd (sing @d))
     instance SingI1 (CartProdSym1 :: [a] -> (~>) [b] [(a, b)]) where
       liftSing (s :: Sing (d :: [a]))
-        = (singFun1 @(CartProdSym1 (d :: [a]))) (sCartProd s)
+        = singFun1 @(CartProdSym1 (d :: [a])) (sCartProd s)
     instance SingI (Zip'Sym0 :: (~>) [a] ((~>) [b] [(a, b)])) where
-      sing = (singFun2 @Zip'Sym0) sZip'
+      sing = singFun2 @Zip'Sym0 sZip'
     instance SingI d =>
              SingI (Zip'Sym1 (d :: [a]) :: (~>) [b] [(a, b)]) where
-      sing = (singFun1 @(Zip'Sym1 (d :: [a]))) (sZip' (sing @d))
+      sing = singFun1 @(Zip'Sym1 (d :: [a])) (sZip' (sing @d))
     instance SingI1 (Zip'Sym1 :: [a] -> (~>) [b] [(a, b)]) where
       liftSing (s :: Sing (d :: [a]))
-        = (singFun1 @(Zip'Sym1 (d :: [a]))) (sZip' s)
+        = singFun1 @(Zip'Sym1 (d :: [a])) (sZip' s)
     instance SingI (BoogieSym0 :: (~>) (Maybe a) ((~>) (Maybe Bool) (Maybe a))) where
-      sing = (singFun2 @BoogieSym0) sBoogie
+      sing = singFun2 @BoogieSym0 sBoogie
     instance SingI d =>
              SingI (BoogieSym1 (d :: Maybe a) :: (~>) (Maybe Bool) (Maybe a)) where
-      sing = (singFun1 @(BoogieSym1 (d :: Maybe a))) (sBoogie (sing @d))
+      sing = singFun1 @(BoogieSym1 (d :: Maybe a)) (sBoogie (sing @d))
     instance SingI1 (BoogieSym1 :: Maybe a
                                    -> (~>) (Maybe Bool) (Maybe a)) where
       liftSing (s :: Sing (d :: Maybe a))
-        = (singFun1 @(BoogieSym1 (d :: Maybe a))) (sBoogie s)
+        = singFun1 @(BoogieSym1 (d :: Maybe a)) (sBoogie s)
diff --git a/tests/compile-and-dump/Singletons/T187.golden b/tests/compile-and-dump/Singletons/T187.golden
--- a/tests/compile-and-dump/Singletons/T187.golden
+++ b/tests/compile-and-dump/Singletons/T187.golden
@@ -11,83 +11,34 @@
     type TFHelper_0123456789876543210 :: Empty -> Empty -> Bool
     type family TFHelper_0123456789876543210 (a :: Empty) (a :: Empty) :: Bool where
       TFHelper_0123456789876543210 _ _ = TrueSym0
-    type TFHelper_0123456789876543210Sym0 :: (~>) Empty ((~>) Empty Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) Empty ((~>) Empty Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Empty -> (~>) Empty Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Empty) :: (~>) Empty Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Empty -> Empty -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Empty) (a0123456789876543210 :: Empty) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PEq Empty where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
+      type (==) a a = TFHelper_0123456789876543210 a a
     type Compare_0123456789876543210 :: Empty -> Empty -> Ordering
     type family Compare_0123456789876543210 (a :: Empty) (a :: Empty) :: Ordering where
       Compare_0123456789876543210 _ _ = EQSym0
-    type Compare_0123456789876543210Sym0 :: (~>) Empty ((~>) Empty Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) Empty ((~>) Empty Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: Empty
-                                            -> (~>) Empty Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Empty) :: (~>) Empty Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: Empty -> Empty -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: Empty) (a0123456789876543210 :: Empty) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance POrd Empty where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
+      type Compare a a = Compare_0123456789876543210 a a
     data SEmpty :: Empty -> Type
     type instance Sing @Empty = SEmpty
     instance SingKind Empty where
       type Demote Empty = Empty
-      fromSing x = case x of {}
-      toSing x = SomeSing (case x of {})
+      fromSing x = (\case) x
+      toSing x = SomeSing ((\case) x)
     instance SEq Empty where
-      (%==) ::
-        forall (t1 :: Empty) (t2 :: Empty). Sing t1
-                                            -> Sing t2
-                                               -> Sing (Apply (Apply ((==@#@$) :: TyFun Empty ((~>) Empty Bool)
-                                                                                  -> Type) t1) t2)
       (%==) _ _ = STrue
     instance SOrd Empty where
-      sCompare ::
-        forall (t1 :: Empty) (t2 :: Empty). Sing t1
-                                            -> Sing t2
-                                               -> Sing (Apply (Apply (CompareSym0 :: TyFun Empty ((~>) Empty Ordering)
-                                                                                     -> Type) t1) t2)
       sCompare _ _ = SEQ
     instance SDecide Empty where
-      (%~) x _ = Proved (case x of {})
-    instance Data.Type.Equality.TestEquality (SEmpty :: Empty
-                                                        -> Type) where
-      Data.Type.Equality.testEquality
+      (%~) x _ = Proved ((\case) x)
+    instance Eq (SEmpty (z :: Empty)) where
+      (==) _ _ = True
+    instance GHC.Internal.Data.Type.Equality.TestEquality (SEmpty :: Empty
+                                                                     -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
         = Data.Singletons.Decide.decideEquality
-    instance Data.Type.Coercion.TestCoercion (SEmpty :: Empty
-                                                        -> Type) where
-      Data.Type.Coercion.testCoercion
+    instance GHC.Internal.Data.Type.Coercion.TestCoercion (SEmpty :: Empty
+                                                                     -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
         = Data.Singletons.Decide.decideCoercion
+    instance Ord (SEmpty (z :: Empty)) where
+      compare _ _ = EQ
diff --git a/tests/compile-and-dump/Singletons/T190.golden b/tests/compile-and-dump/Singletons/T190.golden
--- a/tests/compile-and-dump/Singletons/T190.golden
+++ b/tests/compile-and-dump/Singletons/T190.golden
@@ -13,146 +13,54 @@
     type TFHelper_0123456789876543210 :: T -> T -> Bool
     type family TFHelper_0123456789876543210 (a :: T) (a :: T) :: Bool where
       TFHelper_0123456789876543210 T T = TrueSym0
-    type TFHelper_0123456789876543210Sym0 :: (~>) T ((~>) T Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) T ((~>) T Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: T -> (~>) T Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: T) :: (~>) T Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: T -> T -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: T) (a0123456789876543210 :: T) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PEq T where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
+      type (==) a a = TFHelper_0123456789876543210 a a
     type Compare_0123456789876543210 :: T -> T -> Ordering
     type family Compare_0123456789876543210 (a :: T) (a :: T) :: Ordering where
-      Compare_0123456789876543210 T T = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) NilSym0
-    type Compare_0123456789876543210Sym0 :: (~>) T ((~>) T Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) T ((~>) T Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: T -> (~>) T Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: T) :: (~>) T Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: T -> T -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: T) (a0123456789876543210 :: T) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
+      Compare_0123456789876543210 T T = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
     instance POrd T where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
-    type family Case_0123456789876543210 n t where
-      Case_0123456789876543210 n 'True = TSym0
-      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"
-    type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> T
-    type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: T where
-      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0))
-    type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural T
-    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural T
+      type Compare a a = Compare_0123456789876543210 a a
+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 n 'True = TSym0
+      LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"
+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
       where
-        ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>
-                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())
-    type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> T
-    type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: T where
-      ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210
-    type FromEnum_0123456789876543210 :: T -> GHC.Num.Natural.Natural
-    type family FromEnum_0123456789876543210 (a :: T) :: GHC.Num.Natural.Natural where
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                       -> T
+    type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: T where
+      ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0))
+    type FromEnum_0123456789876543210 :: T
+                                         -> GHC.Internal.Bignum.Natural.Natural
+    type family FromEnum_0123456789876543210 (a :: T) :: GHC.Internal.Bignum.Natural.Natural where
       FromEnum_0123456789876543210 T = FromInteger 0
-    type FromEnum_0123456789876543210Sym0 :: (~>) T GHC.Num.Natural.Natural
-    data FromEnum_0123456789876543210Sym0 :: (~>) T GHC.Num.Natural.Natural
-      where
-        FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>
-                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())
-    type FromEnum_0123456789876543210Sym1 :: T
-                                             -> GHC.Num.Natural.Natural
-    type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: T) :: GHC.Num.Natural.Natural where
-      FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210
     instance PEnum T where
-      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a
-      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a
+      type ToEnum a = ToEnum_0123456789876543210 a
+      type FromEnum a = FromEnum_0123456789876543210 a
     type MinBound_0123456789876543210 :: T
     type family MinBound_0123456789876543210 :: T where
       MinBound_0123456789876543210 = TSym0
-    type MinBound_0123456789876543210Sym0 :: T
-    type family MinBound_0123456789876543210Sym0 :: T where
-      MinBound_0123456789876543210Sym0 = MinBound_0123456789876543210
     type MaxBound_0123456789876543210 :: T
     type family MaxBound_0123456789876543210 :: T where
       MaxBound_0123456789876543210 = TSym0
-    type MaxBound_0123456789876543210Sym0 :: T
-    type family MaxBound_0123456789876543210Sym0 :: T where
-      MaxBound_0123456789876543210Sym0 = MaxBound_0123456789876543210
     instance PBounded T where
-      type MinBound = MinBound_0123456789876543210Sym0
-      type MaxBound = MaxBound_0123456789876543210Sym0
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> T -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: T) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where
+      type MinBound = MinBound_0123456789876543210
+      type MaxBound = MaxBound_0123456789876543210
+    type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                          -> T
+                                             -> GHC.Internal.Types.Symbol
+                                                -> GHC.Internal.Types.Symbol
+    type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: T) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where
       ShowsPrec_0123456789876543210 _ T a_0123456789876543210 = Apply (Apply ShowStringSym0 "T") a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> T -> (~>) GHC.Types.Symbol GHC.Types.Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: T) :: (~>) GHC.Types.Symbol GHC.Types.Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> T -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: T) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PShow T where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
     data ST :: T -> Type where ST :: ST (T :: T)
     type instance Sing @T = ST
     instance SingKind T where
@@ -160,74 +68,55 @@
       fromSing ST = T
       toSing T = SomeSing ST
     instance SEq T where
-      (%==) ::
-        forall (t1 :: T) (t2 :: T). Sing t1
-                                    -> Sing t2
-                                       -> Sing (Apply (Apply ((==@#@$) :: TyFun T ((~>) T Bool)
-                                                                          -> Type) t1) t2)
       (%==) ST ST = STrue
     instance SOrd T where
-      sCompare ::
-        forall (t1 :: T) (t2 :: T). Sing t1
-                                    -> Sing t2
-                                       -> Sing (Apply (Apply (CompareSym0 :: TyFun T ((~>) T Ordering)
-                                                                             -> Type) t1) t2)
       sCompare ST ST
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
             SNil
     instance SEnum T where
-      sToEnum ::
-        forall (t :: GHC.Num.Natural.Natural). Sing t
-                                               -> Sing (Apply (Data.Singletons.Base.Enum.ToEnumSym0 :: TyFun GHC.Num.Natural.Natural T
-                                                                                                       -> Type) t)
-      sFromEnum ::
-        forall (t :: T). Sing t
-                         -> Sing (Apply (Data.Singletons.Base.Enum.FromEnumSym0 :: TyFun T GHC.Num.Natural.Natural
-                                                                                   -> Type) t)
       sToEnum (sN :: Sing n)
-        = (id
-             @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)))))
-            (case
-                 (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))
-                   (sFromInteger (sing :: Sing 0))
-             of
-               STrue -> ST
-               SFalse -> sError (sing :: Sing "toEnum: bad argument"))
+        = applySing
+            (singFun1
+               @(LamCases_0123456789876543210Sym0 n)
+               (\cases
+                  STrue -> ST
+                  SFalse
+                    -> applySing
+                         (singFun1 @ErrorSym0 sError)
+                         (sing :: Sing "toEnum: bad argument")))
+            (applySing
+               (applySing (singFun2 @(==@#@$) (%==)) sN)
+               (sFromInteger (sing :: Sing 0)))
       sFromEnum ST = sFromInteger (sing :: Sing 0)
     instance SBounded T where
-      sMinBound :: Sing (MinBoundSym0 :: T)
-      sMaxBound :: Sing (MaxBoundSym0 :: T)
       sMinBound = ST
       sMaxBound = ST
     instance SShow T where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: T)
-               (t3 :: GHC.Types.Symbol). Sing t1
-                                         -> Sing t2
-                                            -> Sing t3
-                                               -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-                                                                                              -> Type) t1) t2) t3)
       sShowsPrec
         _
         ST
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "T")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "T"))
             sA_0123456789876543210
     instance SDecide T where
       (%~) ST ST = Proved Refl
-    instance Data.Type.Equality.TestEquality (ST :: T -> Type) where
-      Data.Type.Equality.testEquality
+    instance Eq (ST (z :: T)) where
+      (==) _ _ = True
+    instance GHC.Internal.Data.Type.Equality.TestEquality (ST :: T
+                                                                 -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
         = Data.Singletons.Decide.decideEquality
-    instance Data.Type.Coercion.TestCoercion (ST :: T -> Type) where
-      Data.Type.Coercion.testCoercion
+    instance GHC.Internal.Data.Type.Coercion.TestCoercion (ST :: T
+                                                                 -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
         = Data.Singletons.Decide.decideCoercion
+    instance Ord (ST (z :: T)) where
+      compare _ _ = EQ
     deriving instance Show (ST (z :: T))
     instance SingI T where
       sing = ST
diff --git a/tests/compile-and-dump/Singletons/T197.golden b/tests/compile-and-dump/Singletons/T197.golden
--- a/tests/compile-and-dump/Singletons/T197.golden
+++ b/tests/compile-and-dump/Singletons/T197.golden
@@ -13,36 +13,36 @@
       where
         (:$$:@#@$###) :: SameKind (Apply ($$:@#@$) arg) (($$:@#@$$) arg) =>
                          ($$:@#@$) a0123456789876543210
-    type instance Apply ($$:@#@$) a0123456789876543210 = ($$:@#@$$) a0123456789876543210
+    type instance Apply @Bool @((~>) Bool Bool) ($$:@#@$) a0123456789876543210 = ($$:@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings ($$:@#@$) where
-      suppressUnusedWarnings = snd (((,) (:$$:@#@$###)) ())
-    infixl 5 $$:@#@$
+      suppressUnusedWarnings = snd ((,) (:$$:@#@$###) ())
+    infixl 5 type $$:@#@$
     type ($$:@#@$$) :: Bool -> (~>) Bool Bool
     data ($$:@#@$$) (a0123456789876543210 :: Bool) :: (~>) Bool Bool
       where
         (:$$:@#@$$###) :: SameKind (Apply (($$:@#@$$) a0123456789876543210) arg) (($$:@#@$$$) a0123456789876543210 arg) =>
                           ($$:@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply (($$:@#@$$) a0123456789876543210) a0123456789876543210 = ($$:) a0123456789876543210 a0123456789876543210
+    type instance Apply @Bool @Bool (($$:@#@$$) a0123456789876543210) a0123456789876543210 = ($$:) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (($$:@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:$$:@#@$$###)) ())
-    infixl 5 $$:@#@$$
+      suppressUnusedWarnings = snd ((,) (:$$:@#@$$###) ())
+    infixl 5 type $$:@#@$$
     type ($$:@#@$$$) :: Bool -> Bool -> Bool
     type family ($$:@#@$$$) (a0123456789876543210 :: Bool) (a0123456789876543210 :: Bool) :: Bool where
       ($$:@#@$$$) a0123456789876543210 a0123456789876543210 = ($$:) a0123456789876543210 a0123456789876543210
-    infixl 5 $$:@#@$$$
+    infixl 5 type $$:@#@$$$
     type ($$:) :: Bool -> Bool -> Bool
     type family ($$:) (a :: Bool) (a :: Bool) :: Bool where
       ($$:) _ _ = FalseSym0
-    infixl 5 %$$:
+    infixl 5 data %$$:
     (%$$:) ::
-      forall (t :: Bool) (t :: Bool). Sing t
-                                      -> Sing t -> Sing (Apply (Apply ($$:@#@$) t) t :: Bool)
+      (forall (t :: Bool) (t :: Bool).
+       Sing t -> Sing t -> Sing (($$:) t t :: Bool) :: Type)
     (%$$:) _ _ = SFalse
     instance SingI (($$:@#@$) :: (~>) Bool ((~>) Bool Bool)) where
-      sing = (singFun2 @($$:@#@$)) (%$$:)
+      sing = singFun2 @($$:@#@$) (%$$:)
     instance SingI d =>
              SingI (($$:@#@$$) (d :: Bool) :: (~>) Bool Bool) where
-      sing = (singFun1 @(($$:@#@$$) (d :: Bool))) ((%$$:) (sing @d))
+      sing = singFun1 @(($$:@#@$$) (d :: Bool)) ((%$$:) (sing @d))
     instance SingI1 (($$:@#@$$) :: Bool -> (~>) Bool Bool) where
       liftSing (s :: Sing (d :: Bool))
-        = (singFun1 @(($$:@#@$$) (d :: Bool))) ((%$$:) s)
+        = singFun1 @(($$:@#@$$) (d :: Bool)) ((%$$:) s)
diff --git a/tests/compile-and-dump/Singletons/T197b.golden b/tests/compile-and-dump/Singletons/T197b.golden
--- a/tests/compile-and-dump/Singletons/T197b.golden
+++ b/tests/compile-and-dump/Singletons/T197b.golden
@@ -14,43 +14,43 @@
       where
         (::*:@#@$###) :: SameKind (Apply (:*:@#@$) arg) ((:*:@#@$$) arg) =>
                          (:*:@#@$) a0123456789876543210
-    type instance Apply (:*:@#@$) a0123456789876543210 = (:*:@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) b ((:*:) a b)) (:*:@#@$) a0123456789876543210 = (:*:@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:*:@#@$) where
-      suppressUnusedWarnings = snd (((,) (::*:@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (::*:@#@$###) ())
     type (:*:@#@$$) :: forall a b. a -> (~>) b ((:*:) a b)
     data (:*:@#@$$) (a0123456789876543210 :: a) :: (~>) b ((:*:) a b)
       where
         (::*:@#@$$###) :: SameKind (Apply ((:*:@#@$$) a0123456789876543210) arg) ((:*:@#@$$$) a0123456789876543210 arg) =>
                           (:*:@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:*:@#@$$) a0123456789876543210) a0123456789876543210 = (:*:) a0123456789876543210 a0123456789876543210
+    type instance Apply @b @((:*:) a b) ((:*:@#@$$) a0123456789876543210) a0123456789876543210 = (:*:) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:*:@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::*:@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (::*:@#@$$###) ())
     type (:*:@#@$$$) :: forall a b. a -> b -> (:*:) a b
-    type family (:*:@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (:*:) a b where
+    type family (:*:@#@$$$) @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (:*:) a b where
       (:*:@#@$$$) a0123456789876543210 a0123456789876543210 = (:*:) a0123456789876543210 a0123456789876543210
     type MkPairSym0 :: forall a b. (~>) a ((~>) b (Pair a b))
     data MkPairSym0 :: (~>) a ((~>) b (Pair a b))
       where
         MkPairSym0KindInference :: SameKind (Apply MkPairSym0 arg) (MkPairSym1 arg) =>
                                    MkPairSym0 a0123456789876543210
-    type instance Apply MkPairSym0 a0123456789876543210 = MkPairSym1 a0123456789876543210
+    type instance Apply @a @((~>) b (Pair a b)) MkPairSym0 a0123456789876543210 = MkPairSym1 a0123456789876543210
     instance SuppressUnusedWarnings MkPairSym0 where
-      suppressUnusedWarnings = snd (((,) MkPairSym0KindInference) ())
-    infixr 9 `MkPairSym0`
+      suppressUnusedWarnings = snd ((,) MkPairSym0KindInference ())
+    infixr 9 type `MkPairSym0`
     type MkPairSym1 :: forall a b. a -> (~>) b (Pair a b)
     data MkPairSym1 (a0123456789876543210 :: a) :: (~>) b (Pair a b)
       where
         MkPairSym1KindInference :: SameKind (Apply (MkPairSym1 a0123456789876543210) arg) (MkPairSym2 a0123456789876543210 arg) =>
                                    MkPairSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkPairSym1 a0123456789876543210) a0123456789876543210 = MkPair a0123456789876543210 a0123456789876543210
+    type instance Apply @b @(Pair a b) (MkPairSym1 a0123456789876543210) a0123456789876543210 = MkPair a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MkPairSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkPairSym1KindInference) ())
-    infixr 9 `MkPairSym1`
+      suppressUnusedWarnings = snd ((,) MkPairSym1KindInference ())
+    infixr 9 type `MkPairSym1`
     type MkPairSym2 :: forall a b. a -> b -> Pair a b
-    type family MkPairSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Pair a b where
+    type family MkPairSym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Pair a b where
       MkPairSym2 a0123456789876543210 a0123456789876543210 = MkPair a0123456789876543210 a0123456789876543210
-    infixr 9 `MkPairSym2`
-    infixr 9 `SMkPair`
+    infixr 9 type `MkPairSym2`
+    infixr 9 data `SMkPair`
     data (%:*:) :: forall a b. (:*:) a b -> Type
       where
         (:%*:) :: forall a b (n :: a) (n :: b).
@@ -58,10 +58,10 @@
     type instance Sing @((:*:) a b) = (%:*:)
     instance (SingKind a, SingKind b) => SingKind ((:*:) a b) where
       type Demote ((:*:) a b) = (:*:) (Demote a) (Demote b)
-      fromSing ((:%*:) b b) = ((:*:) (fromSing b)) (fromSing b)
+      fromSing ((:%*:) b b) = (:*:) (fromSing b) (fromSing b)
       toSing ((:*:) (b :: Demote a) (b :: Demote b))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:%*:) c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
     data SPair :: forall a b. Pair a b -> Type
       where
         SMkPair :: forall a b (n :: a) (n :: b).
@@ -69,37 +69,37 @@
     type instance Sing @(Pair a b) = SPair
     instance (SingKind a, SingKind b) => SingKind (Pair a b) where
       type Demote (Pair a b) = Pair (Demote a) (Demote b)
-      fromSing (SMkPair b b) = (MkPair (fromSing b)) (fromSing b)
+      fromSing (SMkPair b b) = MkPair (fromSing b) (fromSing b)
       toSing (MkPair (b :: Demote a) (b :: Demote b))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkPair c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SMkPair c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
     instance (SingI n, SingI n) =>
              SingI ((:*:) (n :: a) (n :: b)) where
-      sing = ((:%*:) sing) sing
+      sing = (:%*:) sing sing
     instance SingI n => SingI1 ((:*:) (n :: a)) where
       liftSing = (:%*:) sing
     instance SingI2 (:*:) where
       liftSing2 = (:%*:)
     instance SingI ((:*:@#@$) :: (~>) a ((~>) b ((:*:) a b))) where
-      sing = (singFun2 @(:*:@#@$)) (:%*:)
+      sing = singFun2 @(:*:@#@$) (:%*:)
     instance SingI d =>
              SingI ((:*:@#@$$) (d :: a) :: (~>) b ((:*:) a b)) where
-      sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d))
+      sing = singFun1 @((:*:@#@$$) (d :: a)) ((:%*:) (sing @d))
     instance SingI1 ((:*:@#@$$) :: a -> (~>) b ((:*:) a b)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) s)
+        = singFun1 @((:*:@#@$$) (d :: a)) ((:%*:) s)
     instance (SingI n, SingI n) =>
              SingI (MkPair (n :: a) (n :: b)) where
-      sing = (SMkPair sing) sing
+      sing = SMkPair sing sing
     instance SingI n => SingI1 (MkPair (n :: a)) where
       liftSing = SMkPair sing
     instance SingI2 MkPair where
       liftSing2 = SMkPair
     instance SingI (MkPairSym0 :: (~>) a ((~>) b (Pair a b))) where
-      sing = (singFun2 @MkPairSym0) SMkPair
+      sing = singFun2 @MkPairSym0 SMkPair
     instance SingI d =>
              SingI (MkPairSym1 (d :: a) :: (~>) b (Pair a b)) where
-      sing = (singFun1 @(MkPairSym1 (d :: a))) (SMkPair (sing @d))
+      sing = singFun1 @(MkPairSym1 (d :: a)) (SMkPair (sing @d))
     instance SingI1 (MkPairSym1 :: a -> (~>) b (Pair a b)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(MkPairSym1 (d :: a))) (SMkPair s)
+        = singFun1 @(MkPairSym1 (d :: a)) (SMkPair s)
diff --git a/tests/compile-and-dump/Singletons/T200.golden b/tests/compile-and-dump/Singletons/T200.golden
--- a/tests/compile-and-dump/Singletons/T200.golden
+++ b/tests/compile-and-dump/Singletons/T200.golden
@@ -23,17 +23,17 @@
       where
         (::$$:@#@$###) :: SameKind (Apply (:$$:@#@$) arg) ((:$$:@#@$$) arg) =>
                           (:$$:@#@$) a0123456789876543210
-    type instance Apply (:$$:@#@$) a0123456789876543210 = (:$$:@#@$$) a0123456789876543210
+    type instance Apply @ErrorMessage @((~>) ErrorMessage ErrorMessage) (:$$:@#@$) a0123456789876543210 = (:$$:@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:$$:@#@$) where
-      suppressUnusedWarnings = snd (((,) (::$$:@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (::$$:@#@$###) ())
     type (:$$:@#@$$) :: ErrorMessage -> (~>) ErrorMessage ErrorMessage
     data (:$$:@#@$$) (a0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage
       where
         (::$$:@#@$$###) :: SameKind (Apply ((:$$:@#@$$) a0123456789876543210) arg) ((:$$:@#@$$$) a0123456789876543210 arg) =>
                            (:$$:@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:$$:@#@$$) a0123456789876543210) a0123456789876543210 = (:$$:) a0123456789876543210 a0123456789876543210
+    type instance Apply @ErrorMessage @ErrorMessage ((:$$:@#@$$) a0123456789876543210) a0123456789876543210 = (:$$:) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:$$:@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::$$:@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (::$$:@#@$$###) ())
     type (:$$:@#@$$$) :: ErrorMessage -> ErrorMessage -> ErrorMessage
     type family (:$$:@#@$$$) (a0123456789876543210 :: ErrorMessage) (a0123456789876543210 :: ErrorMessage) :: ErrorMessage where
       (:$$:@#@$$$) a0123456789876543210 a0123456789876543210 = (:$$:) a0123456789876543210 a0123456789876543210
@@ -42,17 +42,17 @@
       where
         (::<>:@#@$###) :: SameKind (Apply (:<>:@#@$) arg) ((:<>:@#@$$) arg) =>
                           (:<>:@#@$) a0123456789876543210
-    type instance Apply (:<>:@#@$) a0123456789876543210 = (:<>:@#@$$) a0123456789876543210
+    type instance Apply @ErrorMessage @((~>) ErrorMessage ErrorMessage) (:<>:@#@$) a0123456789876543210 = (:<>:@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:<>:@#@$) where
-      suppressUnusedWarnings = snd (((,) (::<>:@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (::<>:@#@$###) ())
     type (:<>:@#@$$) :: ErrorMessage -> (~>) ErrorMessage ErrorMessage
     data (:<>:@#@$$) (a0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage
       where
         (::<>:@#@$$###) :: SameKind (Apply ((:<>:@#@$$) a0123456789876543210) arg) ((:<>:@#@$$$) a0123456789876543210 arg) =>
                            (:<>:@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:<>:@#@$$) a0123456789876543210) a0123456789876543210 = (:<>:) a0123456789876543210 a0123456789876543210
+    type instance Apply @ErrorMessage @ErrorMessage ((:<>:@#@$$) a0123456789876543210) a0123456789876543210 = (:<>:) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:<>:@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::<>:@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (::<>:@#@$$###) ())
     type (:<>:@#@$$$) :: ErrorMessage -> ErrorMessage -> ErrorMessage
     type family (:<>:@#@$$$) (a0123456789876543210 :: ErrorMessage) (a0123456789876543210 :: ErrorMessage) :: ErrorMessage where
       (:<>:@#@$$$) a0123456789876543210 a0123456789876543210 = (:<>:) a0123456789876543210 a0123456789876543210
@@ -61,9 +61,9 @@
       where
         EMSym0KindInference :: SameKind (Apply EMSym0 arg) (EMSym1 arg) =>
                                EMSym0 a0123456789876543210
-    type instance Apply EMSym0 a0123456789876543210 = EM a0123456789876543210
+    type instance Apply @[Bool] @ErrorMessage EMSym0 a0123456789876543210 = EM a0123456789876543210
     instance SuppressUnusedWarnings EMSym0 where
-      suppressUnusedWarnings = snd (((,) EMSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) EMSym0KindInference ())
     type EMSym1 :: [Bool] -> ErrorMessage
     type family EMSym1 (a0123456789876543210 :: [Bool]) :: ErrorMessage where
       EMSym1 a0123456789876543210 = EM a0123456789876543210
@@ -72,17 +72,17 @@
       where
         (:<>:@#@$###) :: SameKind (Apply (<>:@#@$) arg) ((<>:@#@$$) arg) =>
                          (<>:@#@$) a0123456789876543210
-    type instance Apply (<>:@#@$) a0123456789876543210 = (<>:@#@$$) a0123456789876543210
+    type instance Apply @ErrorMessage @((~>) ErrorMessage ErrorMessage) (<>:@#@$) a0123456789876543210 = (<>:@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (<>:@#@$) where
-      suppressUnusedWarnings = snd (((,) (:<>:@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (:<>:@#@$###) ())
     type (<>:@#@$$) :: ErrorMessage -> (~>) ErrorMessage ErrorMessage
     data (<>:@#@$$) (a0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage
       where
         (:<>:@#@$$###) :: SameKind (Apply ((<>:@#@$$) a0123456789876543210) arg) ((<>:@#@$$$) a0123456789876543210 arg) =>
                           (<>:@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((<>:@#@$$) a0123456789876543210) a0123456789876543210 = (<>:) a0123456789876543210 a0123456789876543210
+    type instance Apply @ErrorMessage @ErrorMessage ((<>:@#@$$) a0123456789876543210) a0123456789876543210 = (<>:) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((<>:@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:<>:@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (:<>:@#@$$###) ())
     type (<>:@#@$$$) :: ErrorMessage -> ErrorMessage -> ErrorMessage
     type family (<>:@#@$$$) (a0123456789876543210 :: ErrorMessage) (a0123456789876543210 :: ErrorMessage) :: ErrorMessage where
       (<>:@#@$$$) a0123456789876543210 a0123456789876543210 = (<>:) a0123456789876543210 a0123456789876543210
@@ -91,17 +91,17 @@
       where
         (:$$:@#@$###) :: SameKind (Apply ($$:@#@$) arg) (($$:@#@$$) arg) =>
                          ($$:@#@$) a0123456789876543210
-    type instance Apply ($$:@#@$) a0123456789876543210 = ($$:@#@$$) a0123456789876543210
+    type instance Apply @ErrorMessage @((~>) ErrorMessage ErrorMessage) ($$:@#@$) a0123456789876543210 = ($$:@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings ($$:@#@$) where
-      suppressUnusedWarnings = snd (((,) (:$$:@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (:$$:@#@$###) ())
     type ($$:@#@$$) :: ErrorMessage -> (~>) ErrorMessage ErrorMessage
     data ($$:@#@$$) (a0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage
       where
         (:$$:@#@$$###) :: SameKind (Apply (($$:@#@$$) a0123456789876543210) arg) (($$:@#@$$$) a0123456789876543210 arg) =>
                           ($$:@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply (($$:@#@$$) a0123456789876543210) a0123456789876543210 = ($$:) a0123456789876543210 a0123456789876543210
+    type instance Apply @ErrorMessage @ErrorMessage (($$:@#@$$) a0123456789876543210) a0123456789876543210 = ($$:) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (($$:@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:$$:@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (:$$:@#@$$###) ())
     type ($$:@#@$$$) :: ErrorMessage -> ErrorMessage -> ErrorMessage
     type family ($$:@#@$$$) (a0123456789876543210 :: ErrorMessage) (a0123456789876543210 :: ErrorMessage) :: ErrorMessage where
       ($$:@#@$$$) a0123456789876543210 a0123456789876543210 = ($$:) a0123456789876543210 a0123456789876543210
@@ -112,37 +112,35 @@
     type family ($$:) (a :: ErrorMessage) (a :: ErrorMessage) :: ErrorMessage where
       ($$:) x y = Apply (Apply (:$$:@#@$) x) y
     (%<>:) ::
-      forall (t :: ErrorMessage) (t :: ErrorMessage). Sing t
-                                                      -> Sing t
-                                                         -> Sing (Apply (Apply (<>:@#@$) t) t :: ErrorMessage)
+      (forall (t :: ErrorMessage) (t :: ErrorMessage).
+       Sing t -> Sing t -> Sing ((<>:) t t :: ErrorMessage) :: Type)
     (%$$:) ::
-      forall (t :: ErrorMessage) (t :: ErrorMessage). Sing t
-                                                      -> Sing t
-                                                         -> Sing (Apply (Apply ($$:@#@$) t) t :: ErrorMessage)
+      (forall (t :: ErrorMessage) (t :: ErrorMessage).
+       Sing t -> Sing t -> Sing (($$:) t t :: ErrorMessage) :: Type)
     (%<>:) (sX :: Sing x) (sY :: Sing y)
-      = (applySing ((applySing ((singFun2 @(:<>:@#@$)) (:%<>:))) sX)) sY
+      = applySing (applySing (singFun2 @(:<>:@#@$) (:%<>:)) sX) sY
     (%$$:) (sX :: Sing x) (sY :: Sing y)
-      = (applySing ((applySing ((singFun2 @(:$$:@#@$)) (:%$$:))) sX)) sY
+      = applySing (applySing (singFun2 @(:$$:@#@$) (:%$$:)) sX) sY
     instance SingI ((<>:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where
-      sing = (singFun2 @(<>:@#@$)) (%<>:)
+      sing = singFun2 @(<>:@#@$) (%<>:)
     instance SingI d =>
              SingI ((<>:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where
       sing
-        = (singFun1 @((<>:@#@$$) (d :: ErrorMessage))) ((%<>:) (sing @d))
+        = singFun1 @((<>:@#@$$) (d :: ErrorMessage)) ((%<>:) (sing @d))
     instance SingI1 ((<>:@#@$$) :: ErrorMessage
                                    -> (~>) ErrorMessage ErrorMessage) where
       liftSing (s :: Sing (d :: ErrorMessage))
-        = (singFun1 @((<>:@#@$$) (d :: ErrorMessage))) ((%<>:) s)
+        = singFun1 @((<>:@#@$$) (d :: ErrorMessage)) ((%<>:) s)
     instance SingI (($$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where
-      sing = (singFun2 @($$:@#@$)) (%$$:)
+      sing = singFun2 @($$:@#@$) (%$$:)
     instance SingI d =>
              SingI (($$:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where
       sing
-        = (singFun1 @(($$:@#@$$) (d :: ErrorMessage))) ((%$$:) (sing @d))
+        = singFun1 @(($$:@#@$$) (d :: ErrorMessage)) ((%$$:) (sing @d))
     instance SingI1 (($$:@#@$$) :: ErrorMessage
                                    -> (~>) ErrorMessage ErrorMessage) where
       liftSing (s :: Sing (d :: ErrorMessage))
-        = (singFun1 @(($$:@#@$$) (d :: ErrorMessage))) ((%$$:) s)
+        = singFun1 @(($$:@#@$$) (d :: ErrorMessage)) ((%$$:) s)
     data SErrorMessage :: ErrorMessage -> Type
       where
         (:%$$:) :: forall (n :: ErrorMessage) (n :: ErrorMessage).
@@ -154,63 +152,59 @@
     type instance Sing @ErrorMessage = SErrorMessage
     instance SingKind ErrorMessage where
       type Demote ErrorMessage = ErrorMessage
-      fromSing ((:%$$:) b b) = ((:$$:) (fromSing b)) (fromSing b)
-      fromSing ((:%<>:) b b) = ((:<>:) (fromSing b)) (fromSing b)
+      fromSing ((:%$$:) b b) = (:$$:) (fromSing b) (fromSing b)
+      fromSing ((:%<>:) b b) = (:<>:) (fromSing b) (fromSing b)
       fromSing (SEM b) = EM (fromSing b)
       toSing
         ((:$$:) (b :: Demote ErrorMessage) (b :: Demote ErrorMessage))
-        = case
-              ((,) (toSing b :: SomeSing ErrorMessage))
-                (toSing b :: SomeSing ErrorMessage)
-          of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%$$:) c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:%$$:) c c))
+            (toSing b :: SomeSing ErrorMessage)
+            (toSing b :: SomeSing ErrorMessage)
       toSing
         ((:<>:) (b :: Demote ErrorMessage) (b :: Demote ErrorMessage))
-        = case
-              ((,) (toSing b :: SomeSing ErrorMessage))
-                (toSing b :: SomeSing ErrorMessage)
-          of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%<>:) c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:%<>:) c c))
+            (toSing b :: SomeSing ErrorMessage)
+            (toSing b :: SomeSing ErrorMessage)
       toSing (EM (b :: Demote [Bool]))
-        = case toSing b :: SomeSing [Bool] of
-            SomeSing c -> SomeSing (SEM c)
+        = (\cases (SomeSing c) -> SomeSing (SEM c))
+            (toSing b :: SomeSing [Bool])
     instance (SingI n, SingI n) =>
              SingI ((:$$:) (n :: ErrorMessage) (n :: ErrorMessage)) where
-      sing = ((:%$$:) sing) sing
+      sing = (:%$$:) sing sing
     instance SingI n => SingI1 ((:$$:) (n :: ErrorMessage)) where
       liftSing = (:%$$:) sing
     instance SingI2 (:$$:) where
       liftSing2 = (:%$$:)
     instance SingI ((:$$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where
-      sing = (singFun2 @(:$$:@#@$)) (:%$$:)
+      sing = singFun2 @(:$$:@#@$) (:%$$:)
     instance SingI d =>
              SingI ((:$$:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where
       sing
-        = (singFun1 @((:$$:@#@$$) (d :: ErrorMessage))) ((:%$$:) (sing @d))
+        = singFun1 @((:$$:@#@$$) (d :: ErrorMessage)) ((:%$$:) (sing @d))
     instance SingI1 ((:$$:@#@$$) :: ErrorMessage
                                     -> (~>) ErrorMessage ErrorMessage) where
       liftSing (s :: Sing (d :: ErrorMessage))
-        = (singFun1 @((:$$:@#@$$) (d :: ErrorMessage))) ((:%$$:) s)
+        = singFun1 @((:$$:@#@$$) (d :: ErrorMessage)) ((:%$$:) s)
     instance (SingI n, SingI n) =>
              SingI ((:<>:) (n :: ErrorMessage) (n :: ErrorMessage)) where
-      sing = ((:%<>:) sing) sing
+      sing = (:%<>:) sing sing
     instance SingI n => SingI1 ((:<>:) (n :: ErrorMessage)) where
       liftSing = (:%<>:) sing
     instance SingI2 (:<>:) where
       liftSing2 = (:%<>:)
     instance SingI ((:<>:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where
-      sing = (singFun2 @(:<>:@#@$)) (:%<>:)
+      sing = singFun2 @(:<>:@#@$) (:%<>:)
     instance SingI d =>
              SingI ((:<>:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where
       sing
-        = (singFun1 @((:<>:@#@$$) (d :: ErrorMessage))) ((:%<>:) (sing @d))
+        = singFun1 @((:<>:@#@$$) (d :: ErrorMessage)) ((:%<>:) (sing @d))
     instance SingI1 ((:<>:@#@$$) :: ErrorMessage
                                     -> (~>) ErrorMessage ErrorMessage) where
       liftSing (s :: Sing (d :: ErrorMessage))
-        = (singFun1 @((:<>:@#@$$) (d :: ErrorMessage))) ((:%<>:) s)
+        = singFun1 @((:<>:@#@$$) (d :: ErrorMessage)) ((:%<>:) s)
     instance SingI n => SingI (EM (n :: [Bool])) where
       sing = SEM sing
     instance SingI1 EM where
       liftSing = SEM
     instance SingI (EMSym0 :: (~>) [Bool] ErrorMessage) where
-      sing = (singFun1 @EMSym0) SEM
+      sing = singFun1 @EMSym0 SEM
diff --git a/tests/compile-and-dump/Singletons/T204.golden b/tests/compile-and-dump/Singletons/T204.golden
--- a/tests/compile-and-dump/Singletons/T204.golden
+++ b/tests/compile-and-dump/Singletons/T204.golden
@@ -20,87 +20,87 @@
       where
         (::%@#@$###) :: SameKind (Apply (:%@#@$) arg) ((:%@#@$$) arg) =>
                         (:%@#@$) a0123456789876543210
-    type instance Apply (:%@#@$) a0123456789876543210 = (:%@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) a (Ratio1 a)) (:%@#@$) a0123456789876543210 = (:%@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:%@#@$) where
-      suppressUnusedWarnings = snd (((,) (::%@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (::%@#@$###) ())
     type (:%@#@$$) :: forall a. a -> (~>) a (Ratio1 a)
     data (:%@#@$$) (a0123456789876543210 :: a) :: (~>) a (Ratio1 a)
       where
         (::%@#@$$###) :: SameKind (Apply ((:%@#@$$) a0123456789876543210) arg) ((:%@#@$$$) a0123456789876543210 arg) =>
                          (:%@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:%@#@$$) a0123456789876543210) a0123456789876543210 = (:%) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @(Ratio1 a) ((:%@#@$$) a0123456789876543210) a0123456789876543210 = (:%) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:%@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::%@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (::%@#@$$###) ())
     type (:%@#@$$$) :: forall a. a -> a -> Ratio1 a
-    type family (:%@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ratio1 a where
+    type family (:%@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ratio1 a where
       (:%@#@$$$) a0123456789876543210 a0123456789876543210 = (:%) a0123456789876543210 a0123456789876543210
     type (:%%@#@$) :: forall a. (~>) a ((~>) a (Ratio2 a))
     data (:%%@#@$) :: (~>) a ((~>) a (Ratio2 a))
       where
         (::%%@#@$###) :: SameKind (Apply (:%%@#@$) arg) ((:%%@#@$$) arg) =>
                          (:%%@#@$) a0123456789876543210
-    type instance Apply (:%%@#@$) a0123456789876543210 = (:%%@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) a (Ratio2 a)) (:%%@#@$) a0123456789876543210 = (:%%@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:%%@#@$) where
-      suppressUnusedWarnings = snd (((,) (::%%@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (::%%@#@$###) ())
     type (:%%@#@$$) :: forall a. a -> (~>) a (Ratio2 a)
     data (:%%@#@$$) (a0123456789876543210 :: a) :: (~>) a (Ratio2 a)
       where
         (::%%@#@$$###) :: SameKind (Apply ((:%%@#@$$) a0123456789876543210) arg) ((:%%@#@$$$) a0123456789876543210 arg) =>
                           (:%%@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:%%@#@$$) a0123456789876543210) a0123456789876543210 = (:%%) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @(Ratio2 a) ((:%%@#@$$) a0123456789876543210) a0123456789876543210 = (:%%) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:%%@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::%%@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (::%%@#@$$###) ())
     type (:%%@#@$$$) :: forall a. a -> a -> Ratio2 a
-    type family (:%%@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ratio2 a where
+    type family (:%%@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ratio2 a where
       (:%%@#@$$$) a0123456789876543210 a0123456789876543210 = (:%%) a0123456789876543210 a0123456789876543210
-    data SRatio1 :: forall a. Ratio1 a -> GHC.Types.Type
+    data SRatio1 :: forall a. Ratio1 a -> GHC.Internal.Types.Type
       where
         (:^%) :: forall a (n :: a) (n :: a).
                  (Sing n) -> (Sing n) -> SRatio1 ((:%) n n :: Ratio1 a)
     type instance Sing @(Ratio1 a) = SRatio1
     instance SingKind a => SingKind (Ratio1 a) where
       type Demote (Ratio1 a) = Ratio1 (Demote a)
-      fromSing ((:^%) b b) = ((:%) (fromSing b)) (fromSing b)
+      fromSing ((:^%) b b) = (:%) (fromSing b) (fromSing b)
       toSing ((:%) (b :: Demote a) (b :: Demote a))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:^%) c) c)
-    data SRatio2 :: forall a. Ratio2 a -> GHC.Types.Type
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:^%) c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing a)
+    data SRatio2 :: forall a. Ratio2 a -> GHC.Internal.Types.Type
       where
         (:^%%) :: forall a (n :: a) (n :: a).
                   (Sing n) -> (Sing n) -> SRatio2 ((:%%) n n :: Ratio2 a)
     type instance Sing @(Ratio2 a) = SRatio2
     instance SingKind a => SingKind (Ratio2 a) where
       type Demote (Ratio2 a) = Ratio2 (Demote a)
-      fromSing ((:^%%) b b) = ((:%%) (fromSing b)) (fromSing b)
+      fromSing ((:^%%) b b) = (:%%) (fromSing b) (fromSing b)
       toSing ((:%%) (b :: Demote a) (b :: Demote a))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:^%%) c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:^%%) c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing a)
     instance (SingI n, SingI n) => SingI ((:%) (n :: a) (n :: a)) where
-      sing = ((:^%) sing) sing
+      sing = (:^%) sing sing
     instance SingI n => SingI1 ((:%) (n :: a)) where
       liftSing = (:^%) sing
     instance SingI2 (:%) where
       liftSing2 = (:^%)
     instance SingI ((:%@#@$) :: (~>) a ((~>) a (Ratio1 a))) where
-      sing = (singFun2 @(:%@#@$)) (:^%)
+      sing = singFun2 @(:%@#@$) (:^%)
     instance SingI d =>
              SingI ((:%@#@$$) (d :: a) :: (~>) a (Ratio1 a)) where
-      sing = (singFun1 @((:%@#@$$) (d :: a))) ((:^%) (sing @d))
+      sing = singFun1 @((:%@#@$$) (d :: a)) ((:^%) (sing @d))
     instance SingI1 ((:%@#@$$) :: a -> (~>) a (Ratio1 a)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((:%@#@$$) (d :: a))) ((:^%) s)
+        = singFun1 @((:%@#@$$) (d :: a)) ((:^%) s)
     instance (SingI n, SingI n) =>
              SingI ((:%%) (n :: a) (n :: a)) where
-      sing = ((:^%%) sing) sing
+      sing = (:^%%) sing sing
     instance SingI n => SingI1 ((:%%) (n :: a)) where
       liftSing = (:^%%) sing
     instance SingI2 (:%%) where
       liftSing2 = (:^%%)
     instance SingI ((:%%@#@$) :: (~>) a ((~>) a (Ratio2 a))) where
-      sing = (singFun2 @(:%%@#@$)) (:^%%)
+      sing = singFun2 @(:%%@#@$) (:^%%)
     instance SingI d =>
              SingI ((:%%@#@$$) (d :: a) :: (~>) a (Ratio2 a)) where
-      sing = (singFun1 @((:%%@#@$$) (d :: a))) ((:^%%) (sing @d))
+      sing = singFun1 @((:%%@#@$$) (d :: a)) ((:^%%) (sing @d))
     instance SingI1 ((:%%@#@$$) :: a -> (~>) a (Ratio2 a)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((:%%@#@$$) (d :: a))) ((:^%%) s)
+        = singFun1 @((:%%@#@$$) (d :: a)) ((:^%%) s)
diff --git a/tests/compile-and-dump/Singletons/T209.golden b/tests/compile-and-dump/Singletons/T209.golden
--- a/tests/compile-and-dump/Singletons/T209.golden
+++ b/tests/compile-and-dump/Singletons/T209.golden
@@ -25,58 +25,55 @@
       where
         MSym0KindInference :: SameKind (Apply MSym0 arg) (MSym1 arg) =>
                               MSym0 a0123456789876543210
-    type instance Apply MSym0 a0123456789876543210 = MSym1 a0123456789876543210
+    type instance Apply @a @((~>) b ((~>) Bool Bool)) MSym0 a0123456789876543210 = MSym1 a0123456789876543210
     instance SuppressUnusedWarnings MSym0 where
-      suppressUnusedWarnings = snd (((,) MSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MSym0KindInference ())
     type MSym1 :: a -> (~>) b ((~>) Bool Bool)
     data MSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) Bool Bool)
       where
         MSym1KindInference :: SameKind (Apply (MSym1 a0123456789876543210) arg) (MSym2 a0123456789876543210 arg) =>
                               MSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MSym1 a0123456789876543210) a0123456789876543210 = MSym2 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @((~>) Bool Bool) (MSym1 a0123456789876543210) a0123456789876543210 = MSym2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) MSym1KindInference ())
     type MSym2 :: a -> b -> (~>) Bool Bool
     data MSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) Bool Bool
       where
         MSym2KindInference :: SameKind (Apply (MSym2 a0123456789876543210 a0123456789876543210) arg) (MSym3 a0123456789876543210 a0123456789876543210 arg) =>
                               MSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (MSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = M a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @Bool @Bool (MSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = M a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MSym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MSym2KindInference) ())
+      suppressUnusedWarnings = snd ((,) MSym2KindInference ())
     type MSym3 :: a -> b -> Bool -> Bool
-    type family MSym3 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: Bool) :: Bool where
+    type family MSym3 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: Bool) :: Bool where
       MSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = M a0123456789876543210 a0123456789876543210 a0123456789876543210
     type M :: a -> b -> Bool -> Bool
-    type family M (a :: a) (a :: b) (a :: Bool) :: Bool where
+    type family M @a @b (a :: a) (a :: b) (a :: Bool) :: Bool where
       M _ _ x = x
     class PC a b
     instance PC Bool Hm
     instance PC a (Maybe a)
     sM ::
-      forall a b (t :: a) (t :: b) (t :: Bool). Sing t
-                                                -> Sing t
-                                                   -> Sing t
-                                                      -> Sing (Apply (Apply (Apply MSym0 t) t) t :: Bool)
+      (forall (t :: a) (t :: b) (t :: Bool).
+       Sing t -> Sing t -> Sing t -> Sing (M t t t :: Bool) :: Type)
     sM _ _ (sX :: Sing x) = sX
     instance SingI (MSym0 :: (~>) a ((~>) b ((~>) Bool Bool))) where
-      sing = (singFun3 @MSym0) sM
+      sing = singFun3 @MSym0 sM
     instance SingI d =>
              SingI (MSym1 (d :: a) :: (~>) b ((~>) Bool Bool)) where
-      sing = (singFun2 @(MSym1 (d :: a))) (sM (sing @d))
+      sing = singFun2 @(MSym1 (d :: a)) (sM (sing @d))
     instance SingI1 (MSym1 :: a -> (~>) b ((~>) Bool Bool)) where
-      liftSing (s :: Sing (d :: a)) = (singFun2 @(MSym1 (d :: a))) (sM s)
+      liftSing (s :: Sing (d :: a)) = singFun2 @(MSym1 (d :: a)) (sM s)
     instance (SingI d, SingI d) =>
              SingI (MSym2 (d :: a) (d :: b) :: (~>) Bool Bool) where
-      sing
-        = (singFun1 @(MSym2 (d :: a) (d :: b))) ((sM (sing @d)) (sing @d))
+      sing = singFun1 @(MSym2 (d :: a) (d :: b)) (sM (sing @d) (sing @d))
     instance SingI d =>
              SingI1 (MSym2 (d :: a) :: b -> (~>) Bool Bool) where
       liftSing (s :: Sing (d :: b))
-        = (singFun1 @(MSym2 (d :: a) (d :: b))) ((sM (sing @d)) s)
+        = singFun1 @(MSym2 (d :: a) (d :: b)) (sM (sing @d) s)
     instance SingI2 (MSym2 :: a -> b -> (~>) Bool Bool) where
       liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b))
-        = (singFun1 @(MSym2 (d :: a) (d :: b))) ((sM s) s)
+        = singFun1 @(MSym2 (d :: a) (d :: b)) (sM s s)
     data SHm :: Hm -> Type where SHm :: SHm (Hm :: Hm)
     type instance Sing @Hm = SHm
     instance SingKind Hm where
diff --git a/tests/compile-and-dump/Singletons/T209.hs b/tests/compile-and-dump/Singletons/T209.hs
--- a/tests/compile-and-dump/Singletons/T209.hs
+++ b/tests/compile-and-dump/Singletons/T209.hs
@@ -1,5 +1,4 @@
 {-# LANGUAGE DeriveAnyClass #-}
-{-# LANGUAGE DerivingStrategies #-}
 
 module T209 where
 
diff --git a/tests/compile-and-dump/Singletons/T216.golden b/tests/compile-and-dump/Singletons/T216.golden
--- a/tests/compile-and-dump/Singletons/T216.golden
+++ b/tests/compile-and-dump/Singletons/T216.golden
@@ -5,38 +5,38 @@
       where
         MyProxySym0KindInference :: SameKind (Apply MyProxySym0 arg) (MyProxySym1 arg) =>
                                     MyProxySym0 k0123456789876543210
-    type instance Apply MyProxySym0 k0123456789876543210 = MyProxySym1 k0123456789876543210
+    type instance Apply @Type @((~>) k0123456789876543210 Type) MyProxySym0 k0123456789876543210 = MyProxySym1 k0123456789876543210
     instance SuppressUnusedWarnings MyProxySym0 where
-      suppressUnusedWarnings = snd (((,) MyProxySym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MyProxySym0KindInference ())
     data MyProxySym1 (k0123456789876543210 :: Type) :: (~>) k0123456789876543210 Type
       where
         MyProxySym1KindInference :: SameKind (Apply (MyProxySym1 k0123456789876543210) arg) (MyProxySym2 k0123456789876543210 arg) =>
                                     MyProxySym1 k0123456789876543210 e0123456789876543210
-    type instance Apply (MyProxySym1 k0123456789876543210) e0123456789876543210 = MyProxy k0123456789876543210 e0123456789876543210
+    type instance Apply @k0123456789876543210 @Type (MyProxySym1 k0123456789876543210) e0123456789876543210 = MyProxy k0123456789876543210 e0123456789876543210
     instance SuppressUnusedWarnings (MyProxySym1 k0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MyProxySym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) MyProxySym1KindInference ())
     type family MyProxySym2 (k0123456789876543210 :: Type) (e0123456789876543210 :: k0123456789876543210) :: Type where
       MyProxySym2 k0123456789876543210 e0123456789876543210 = MyProxy k0123456789876543210 e0123456789876543210
     data SymmetrySym0 :: (~>) t0123456789876543210 ((~>) t0123456789876543210 ((~>) ((:~:) a0123456789876543210 y0123456789876543210) Type))
       where
         SymmetrySym0KindInference :: SameKind (Apply SymmetrySym0 arg) (SymmetrySym1 arg) =>
                                      SymmetrySym0 a0123456789876543210
-    type instance Apply SymmetrySym0 a0123456789876543210 = SymmetrySym1 a0123456789876543210
+    type instance Apply @t0123456789876543210 @((~>) t0123456789876543210 ((~>) ((:~:) a0123456789876543210 y0123456789876543210) Type)) SymmetrySym0 a0123456789876543210 = SymmetrySym1 a0123456789876543210
     instance SuppressUnusedWarnings SymmetrySym0 where
-      suppressUnusedWarnings = snd (((,) SymmetrySym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SymmetrySym0KindInference ())
     data SymmetrySym1 (a0123456789876543210 :: t0123456789876543210) :: (~>) t0123456789876543210 ((~>) ((:~:) a0123456789876543210 y0123456789876543210) Type)
       where
         SymmetrySym1KindInference :: SameKind (Apply (SymmetrySym1 a0123456789876543210) arg) (SymmetrySym2 a0123456789876543210 arg) =>
                                      SymmetrySym1 a0123456789876543210 y0123456789876543210
-    type instance Apply (SymmetrySym1 a0123456789876543210) y0123456789876543210 = SymmetrySym2 a0123456789876543210 y0123456789876543210
+    type instance Apply @t0123456789876543210 @((~>) ((:~:) a0123456789876543210 y0123456789876543210) Type) (SymmetrySym1 a0123456789876543210) y0123456789876543210 = SymmetrySym2 a0123456789876543210 y0123456789876543210
     instance SuppressUnusedWarnings (SymmetrySym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) SymmetrySym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) SymmetrySym1KindInference ())
     data SymmetrySym2 (a0123456789876543210 :: t0123456789876543210) (y0123456789876543210 :: t0123456789876543210) :: (~>) ((:~:) a0123456789876543210 y0123456789876543210) Type
       where
         SymmetrySym2KindInference :: SameKind (Apply (SymmetrySym2 a0123456789876543210 y0123456789876543210) arg) (SymmetrySym3 a0123456789876543210 y0123456789876543210 arg) =>
                                      SymmetrySym2 a0123456789876543210 y0123456789876543210 e0123456789876543210
-    type instance Apply (SymmetrySym2 a0123456789876543210 y0123456789876543210) e0123456789876543210 = Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210
+    type instance Apply @((:~:) a0123456789876543210 y0123456789876543210) @Type (SymmetrySym2 a0123456789876543210 y0123456789876543210) e0123456789876543210 = Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210
     instance SuppressUnusedWarnings (SymmetrySym2 a0123456789876543210 y0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) SymmetrySym2KindInference) ())
+      suppressUnusedWarnings = snd ((,) SymmetrySym2KindInference ())
     type family SymmetrySym3 (a0123456789876543210 :: t0123456789876543210) (y0123456789876543210 :: t0123456789876543210) (e0123456789876543210 :: (:~:) a0123456789876543210 y0123456789876543210) :: Type where
       SymmetrySym3 a0123456789876543210 y0123456789876543210 e0123456789876543210 = Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210
diff --git a/tests/compile-and-dump/Singletons/T229.golden b/tests/compile-and-dump/Singletons/T229.golden
--- a/tests/compile-and-dump/Singletons/T229.golden
+++ b/tests/compile-and-dump/Singletons/T229.golden
@@ -10,9 +10,9 @@
       where
         US___fooSym0KindInference :: SameKind (Apply US___fooSym0 arg) (US___fooSym1 arg) =>
                                      US___fooSym0 a0123456789876543210
-    type instance Apply US___fooSym0 a0123456789876543210 = US___foo a0123456789876543210
+    type instance Apply @Bool @Bool US___fooSym0 a0123456789876543210 = US___foo a0123456789876543210
     instance SuppressUnusedWarnings US___fooSym0 where
-      suppressUnusedWarnings = snd (((,) US___fooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) US___fooSym0KindInference ())
     type US___fooSym1 :: Bool -> Bool
     type family US___fooSym1 (a0123456789876543210 :: Bool) :: Bool where
       US___fooSym1 a0123456789876543210 = US___foo a0123456789876543210
@@ -20,7 +20,7 @@
     type family US___foo (a :: Bool) :: Bool where
       US___foo _ = TrueSym0
     ___sfoo ::
-      forall (t :: Bool). Sing t -> Sing (Apply US___fooSym0 t :: Bool)
+      (forall (t :: Bool). Sing t -> Sing (US___foo t :: Bool) :: Type)
     ___sfoo _ = STrue
     instance SingI (US___fooSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @US___fooSym0) ___sfoo
+      sing = singFun1 @US___fooSym0 ___sfoo
diff --git a/tests/compile-and-dump/Singletons/T249.golden b/tests/compile-and-dump/Singletons/T249.golden
--- a/tests/compile-and-dump/Singletons/T249.golden
+++ b/tests/compile-and-dump/Singletons/T249.golden
@@ -12,33 +12,33 @@
       where
         MkFoo1Sym0KindInference :: SameKind (Apply MkFoo1Sym0 arg) (MkFoo1Sym1 arg) =>
                                    MkFoo1Sym0 a0123456789876543210
-    type instance Apply MkFoo1Sym0 a0123456789876543210 = MkFoo1 a0123456789876543210
+    type instance Apply @a @(Foo1 a) MkFoo1Sym0 a0123456789876543210 = MkFoo1 a0123456789876543210
     instance SuppressUnusedWarnings MkFoo1Sym0 where
-      suppressUnusedWarnings = snd (((,) MkFoo1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkFoo1Sym0KindInference ())
     type MkFoo1Sym1 :: forall a. a -> Foo1 a
-    type family MkFoo1Sym1 (a0123456789876543210 :: a) :: Foo1 a where
+    type family MkFoo1Sym1 @a (a0123456789876543210 :: a) :: Foo1 a where
       MkFoo1Sym1 a0123456789876543210 = MkFoo1 a0123456789876543210
     type MkFoo2Sym0 :: (~>) x (Foo2 x)
     data MkFoo2Sym0 :: (~>) x (Foo2 x)
       where
         MkFoo2Sym0KindInference :: SameKind (Apply MkFoo2Sym0 arg) (MkFoo2Sym1 arg) =>
                                    MkFoo2Sym0 a0123456789876543210
-    type instance Apply MkFoo2Sym0 a0123456789876543210 = MkFoo2 a0123456789876543210
+    type instance Apply @x @(Foo2 x) MkFoo2Sym0 a0123456789876543210 = MkFoo2 a0123456789876543210
     instance SuppressUnusedWarnings MkFoo2Sym0 where
-      suppressUnusedWarnings = snd (((,) MkFoo2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkFoo2Sym0KindInference ())
     type MkFoo2Sym1 :: x -> Foo2 x
-    type family MkFoo2Sym1 (a0123456789876543210 :: x) :: Foo2 x where
+    type family MkFoo2Sym1 @x (a0123456789876543210 :: x) :: Foo2 x where
       MkFoo2Sym1 a0123456789876543210 = MkFoo2 a0123456789876543210
     type MkFoo3Sym0 :: forall x. (~>) x (Foo3 x)
     data MkFoo3Sym0 :: (~>) x (Foo3 x)
       where
         MkFoo3Sym0KindInference :: SameKind (Apply MkFoo3Sym0 arg) (MkFoo3Sym1 arg) =>
                                    MkFoo3Sym0 a0123456789876543210
-    type instance Apply MkFoo3Sym0 a0123456789876543210 = MkFoo3 a0123456789876543210
+    type instance Apply @x @(Foo3 x) MkFoo3Sym0 a0123456789876543210 = MkFoo3 a0123456789876543210
     instance SuppressUnusedWarnings MkFoo3Sym0 where
-      suppressUnusedWarnings = snd (((,) MkFoo3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkFoo3Sym0KindInference ())
     type MkFoo3Sym1 :: forall x. x -> Foo3 x
-    type family MkFoo3Sym1 (a0123456789876543210 :: x) :: Foo3 x where
+    type family MkFoo3Sym1 @x (a0123456789876543210 :: x) :: Foo3 x where
       MkFoo3Sym1 a0123456789876543210 = MkFoo3 a0123456789876543210
     data SFoo1 :: forall a. Foo1 a -> Type
       where
@@ -49,7 +49,8 @@
       type Demote (Foo1 a) = Foo1 (Demote a)
       fromSing (SMkFoo1 b) = MkFoo1 (fromSing b)
       toSing (MkFoo1 (b :: Demote a))
-        = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SMkFoo1 c)
+        = (\cases (SomeSing c) -> SomeSing (SMkFoo1 c))
+            (toSing b :: SomeSing a)
     data SFoo2 :: forall a. Foo2 a -> Type
       where
         SMkFoo2 :: forall x (n :: x).
@@ -59,7 +60,8 @@
       type Demote (Foo2 a) = Foo2 (Demote a)
       fromSing (SMkFoo2 b) = MkFoo2 (fromSing b)
       toSing (MkFoo2 (b :: Demote x))
-        = case toSing b :: SomeSing x of SomeSing c -> SomeSing (SMkFoo2 c)
+        = (\cases (SomeSing c) -> SomeSing (SMkFoo2 c))
+            (toSing b :: SomeSing x)
     data SFoo3 :: forall a. Foo3 a -> Type
       where
         SMkFoo3 :: forall x (n :: x).
@@ -69,22 +71,23 @@
       type Demote (Foo3 a) = Foo3 (Demote a)
       fromSing (SMkFoo3 b) = MkFoo3 (fromSing b)
       toSing (MkFoo3 (b :: Demote x))
-        = case toSing b :: SomeSing x of SomeSing c -> SomeSing (SMkFoo3 c)
+        = (\cases (SomeSing c) -> SomeSing (SMkFoo3 c))
+            (toSing b :: SomeSing x)
     instance SingI n => SingI (MkFoo1 (n :: a)) where
       sing = SMkFoo1 sing
     instance SingI1 MkFoo1 where
       liftSing = SMkFoo1
     instance SingI (MkFoo1Sym0 :: (~>) a (Foo1 a)) where
-      sing = (singFun1 @MkFoo1Sym0) SMkFoo1
+      sing = singFun1 @MkFoo1Sym0 SMkFoo1
     instance SingI n => SingI (MkFoo2 (n :: x)) where
       sing = SMkFoo2 sing
     instance SingI1 MkFoo2 where
       liftSing = SMkFoo2
     instance SingI (MkFoo2Sym0 :: (~>) x (Foo2 x)) where
-      sing = (singFun1 @MkFoo2Sym0) SMkFoo2
+      sing = singFun1 @MkFoo2Sym0 SMkFoo2
     instance SingI n => SingI (MkFoo3 (n :: x)) where
       sing = SMkFoo3 sing
     instance SingI1 MkFoo3 where
       liftSing = SMkFoo3
     instance SingI (MkFoo3Sym0 :: (~>) x (Foo3 x)) where
-      sing = (singFun1 @MkFoo3Sym0) SMkFoo3
+      sing = singFun1 @MkFoo3Sym0 SMkFoo3
diff --git a/tests/compile-and-dump/Singletons/T271.golden b/tests/compile-and-dump/Singletons/T271.golden
--- a/tests/compile-and-dump/Singletons/T271.golden
+++ b/tests/compile-and-dump/Singletons/T271.golden
@@ -14,158 +14,65 @@
       where Identity :: a -> Identity a
       deriving (Eq, Ord)
     type ConstantSym0 :: forall (a :: Type)
-                                (b :: Type). (~>) a (Constant (a :: Type) (b :: Type))
-    data ConstantSym0 :: (~>) a (Constant (a :: Type) (b :: Type))
+                                (b :: Type). (~>) a (Constant a b)
+    data ConstantSym0 :: (~>) a (Constant a b)
       where
         ConstantSym0KindInference :: SameKind (Apply ConstantSym0 arg) (ConstantSym1 arg) =>
                                      ConstantSym0 a0123456789876543210
-    type instance Apply ConstantSym0 a0123456789876543210 = Constant a0123456789876543210
+    type instance Apply @a @(Constant a b) ConstantSym0 a0123456789876543210 = Constant a0123456789876543210
     instance SuppressUnusedWarnings ConstantSym0 where
-      suppressUnusedWarnings = snd (((,) ConstantSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) ConstantSym0KindInference ())
     type ConstantSym1 :: forall (a :: Type) (b :: Type). a
-                                                         -> Constant (a :: Type) (b :: Type)
-    type family ConstantSym1 (a0123456789876543210 :: a) :: Constant (a :: Type) (b :: Type) where
+                                                         -> Constant a b
+    type family ConstantSym1 @(a :: Type) @(b :: Type) (a0123456789876543210 :: a) :: Constant a b where
       ConstantSym1 a0123456789876543210 = Constant a0123456789876543210
     type IdentitySym0 :: (~>) a (Identity a)
     data IdentitySym0 :: (~>) a (Identity a)
       where
         IdentitySym0KindInference :: SameKind (Apply IdentitySym0 arg) (IdentitySym1 arg) =>
                                      IdentitySym0 a0123456789876543210
-    type instance Apply IdentitySym0 a0123456789876543210 = Identity a0123456789876543210
+    type instance Apply @a @(Identity a) IdentitySym0 a0123456789876543210 = Identity a0123456789876543210
     instance SuppressUnusedWarnings IdentitySym0 where
-      suppressUnusedWarnings = snd (((,) IdentitySym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) IdentitySym0KindInference ())
     type IdentitySym1 :: a -> Identity a
-    type family IdentitySym1 (a0123456789876543210 :: a) :: Identity a where
+    type family IdentitySym1 @a (a0123456789876543210 :: a) :: Identity a where
       IdentitySym1 a0123456789876543210 = Identity a0123456789876543210
-    type TFHelper_0123456789876543210 :: Constant a b
-                                         -> Constant a b -> Bool
-    type family TFHelper_0123456789876543210 (a :: Constant a b) (a :: Constant a b) :: Bool where
-      TFHelper_0123456789876543210 (Constant a_0123456789876543210) (Constant b_0123456789876543210) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
-    type TFHelper_0123456789876543210Sym0 :: (~>) (Constant a b) ((~>) (Constant a b) Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) (Constant a b) ((~>) (Constant a b) Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Constant a b
-                                             -> (~>) (Constant a b) Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Constant a b) :: (~>) (Constant a b) Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Constant a b
-                                             -> Constant a b -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Constant a b) (a0123456789876543210 :: Constant a b) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
+    type TFHelper_0123456789876543210 :: forall a b. Constant a b
+                                                     -> Constant a b -> Bool
+    type family TFHelper_0123456789876543210 @a @b (a :: Constant a b) (a :: Constant a b) :: Bool where
+      TFHelper_0123456789876543210 @a @b (Constant a_0123456789876543210 :: Constant a b) (Constant b_0123456789876543210 :: Constant a b) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
     instance PEq (Constant a b) where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type Compare_0123456789876543210 :: Constant a b
-                                        -> Constant a b -> Ordering
-    type family Compare_0123456789876543210 (a :: Constant a b) (a :: Constant a b) :: Ordering where
-      Compare_0123456789876543210 (Constant a_0123456789876543210) (Constant b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
-    type Compare_0123456789876543210Sym0 :: (~>) (Constant a b) ((~>) (Constant a b) Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) (Constant a b) ((~>) (Constant a b) Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: Constant a b
-                                            -> (~>) (Constant a b) Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Constant a b) :: (~>) (Constant a b) Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: Constant a b
-                                            -> Constant a b -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: Constant a b) (a0123456789876543210 :: Constant a b) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
+      type (==) a a = TFHelper_0123456789876543210 a a
+    type Compare_0123456789876543210 :: forall a b. Constant a b
+                                                    -> Constant a b -> Ordering
+    type family Compare_0123456789876543210 @a @b (a :: Constant a b) (a :: Constant a b) :: Ordering where
+      Compare_0123456789876543210 @a @b (Constant a_0123456789876543210 :: Constant a b) (Constant b_0123456789876543210 :: Constant a b) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
     instance POrd (Constant a b) where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
-    type TFHelper_0123456789876543210 :: Identity a
-                                         -> Identity a -> Bool
-    type family TFHelper_0123456789876543210 (a :: Identity a) (a :: Identity a) :: Bool where
-      TFHelper_0123456789876543210 (Identity a_0123456789876543210) (Identity b_0123456789876543210) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
-    type TFHelper_0123456789876543210Sym0 :: (~>) (Identity a) ((~>) (Identity a) Bool)
-    data TFHelper_0123456789876543210Sym0 :: (~>) (Identity a) ((~>) (Identity a) Bool)
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: Identity a
-                                             -> (~>) (Identity a) Bool
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Identity a) :: (~>) (Identity a) Bool
-      where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: Identity a
-                                             -> Identity a -> Bool
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Identity a) (a0123456789876543210 :: Identity a) :: Bool where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
+      type Compare a a = Compare_0123456789876543210 a a
+    type TFHelper_0123456789876543210 :: forall a. Identity a
+                                                   -> Identity a -> Bool
+    type family TFHelper_0123456789876543210 @a (a :: Identity a) (a :: Identity a) :: Bool where
+      TFHelper_0123456789876543210 @a (Identity a_0123456789876543210 :: Identity a) (Identity b_0123456789876543210 :: Identity a) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210
     instance PEq (Identity a) where
-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type Compare_0123456789876543210 :: Identity a
-                                        -> Identity a -> Ordering
-    type family Compare_0123456789876543210 (a :: Identity a) (a :: Identity a) :: Ordering where
-      Compare_0123456789876543210 (Identity a_0123456789876543210) (Identity b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
-    type Compare_0123456789876543210Sym0 :: (~>) (Identity a) ((~>) (Identity a) Ordering)
-    data Compare_0123456789876543210Sym0 :: (~>) (Identity a) ((~>) (Identity a) Ordering)
-      where
-        Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>
-                                                        Compare_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())
-    type Compare_0123456789876543210Sym1 :: Identity a
-                                            -> (~>) (Identity a) Ordering
-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Identity a) :: (~>) (Identity a) Ordering
-      where
-        Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                        Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())
-    type Compare_0123456789876543210Sym2 :: Identity a
-                                            -> Identity a -> Ordering
-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: Identity a) (a0123456789876543210 :: Identity a) :: Ordering where
-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210
+      type (==) a a = TFHelper_0123456789876543210 a a
+    type Compare_0123456789876543210 :: forall a. Identity a
+                                                  -> Identity a -> Ordering
+    type family Compare_0123456789876543210 @a (a :: Identity a) (a :: Identity a) :: Ordering where
+      Compare_0123456789876543210 @a (Identity a_0123456789876543210 :: Identity a) (Identity b_0123456789876543210 :: Identity a) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) NilSym0)
     instance POrd (Identity a) where
-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a
+      type Compare a a = Compare_0123456789876543210 a a
     data SConstant :: forall (a :: Type) (b :: Type).
                       Constant a b -> Type
       where
         SConstant :: forall (a :: Type) (b :: Type) (n :: a).
-                     (Sing n) ->
-                     SConstant (Constant n :: Constant (a :: Type) (b :: Type))
+                     (Sing n) -> SConstant (Constant n :: Constant a b)
     type instance Sing @(Constant a b) = SConstant
     instance (SingKind a, SingKind b) => SingKind (Constant a b) where
       type Demote (Constant a b) = Constant (Demote a) (Demote b)
       fromSing (SConstant b) = Constant (fromSing b)
       toSing (Constant (b :: Demote a))
-        = case toSing b :: SomeSing a of
-            SomeSing c -> SomeSing (SConstant c)
+        = (\cases (SomeSing c) -> SomeSing (SConstant c))
+            (toSing b :: SomeSing a)
     data SIdentity :: forall (a :: Type). Identity a -> Type
       where
         SIdentity :: forall a (n :: a).
@@ -175,115 +82,101 @@
       type Demote (Identity a) = Identity (Demote a)
       fromSing (SIdentity b) = Identity (fromSing b)
       toSing (Identity (b :: Demote a))
-        = case toSing b :: SomeSing a of
-            SomeSing c -> SomeSing (SIdentity c)
+        = (\cases (SomeSing c) -> SomeSing (SIdentity c))
+            (toSing b :: SomeSing a)
     instance SEq a => SEq (Constant a b) where
-      (%==) ::
-        forall (t1 :: Constant a b) (t2 :: Constant a b). Sing t1
-                                                          -> Sing t2
-                                                             -> Sing (Apply (Apply ((==@#@$) :: TyFun (Constant a b) ((~>) (Constant a b) Bool)
-                                                                                                -> Type) t1) t2)
       (%==)
         (SConstant (sA_0123456789876543210 :: Sing a_0123456789876543210))
         (SConstant (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
+        = applySing
+            (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
             sB_0123456789876543210
     instance SOrd a => SOrd (Constant a b) where
-      sCompare ::
-        forall (t1 :: Constant a b) (t2 :: Constant a b). Sing t1
-                                                          -> Sing t2
-                                                             -> Sing (Apply (Apply (CompareSym0 :: TyFun (Constant a b) ((~>) (Constant a b) Ordering)
-                                                                                                   -> Type) t1) t2)
       sCompare
         (SConstant (sA_0123456789876543210 :: Sing a_0123456789876543210))
         (SConstant (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
                SNil)
     instance SEq a => SEq (Identity a) where
-      (%==) ::
-        forall (t1 :: Identity a) (t2 :: Identity a). Sing t1
-                                                      -> Sing t2
-                                                         -> Sing (Apply (Apply ((==@#@$) :: TyFun (Identity a) ((~>) (Identity a) Bool)
-                                                                                            -> Type) t1) t2)
       (%==)
         (SIdentity (sA_0123456789876543210 :: Sing a_0123456789876543210))
         (SIdentity (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210))
+        = applySing
+            (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210)
             sB_0123456789876543210
     instance SOrd a => SOrd (Identity a) where
-      sCompare ::
-        forall (t1 :: Identity a) (t2 :: Identity a). Sing t1
-                                                      -> Sing t2
-                                                         -> Sing (Apply (Apply (CompareSym0 :: TyFun (Identity a) ((~>) (Identity a) Ordering)
-                                                                                               -> Type) t1) t2)
       sCompare
         (SIdentity (sA_0123456789876543210 :: Sing a_0123456789876543210))
         (SIdentity (sB_0123456789876543210 :: Sing b_0123456789876543210))
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))
-                    ((singFun2 @ThenCmpSym0) sThenCmp)))
-                SEQ))
-            ((applySing
-                ((applySing ((singFun2 @(:@#@$)) SCons))
-                   ((applySing
-                       ((applySing ((singFun2 @CompareSym0) sCompare))
-                          sA_0123456789876543210))
-                      sB_0123456789876543210)))
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            (applySing
+               (applySing
+                  (singFun2 @(:@#@$) SCons)
+                  (applySing
+                     (applySing (singFun2 @CompareSym0 sCompare) sA_0123456789876543210)
+                     sB_0123456789876543210))
                SNil)
     instance SDecide a => SDecide (Constant a b) where
       (%~) (SConstant a) (SConstant b)
-        = case ((%~) a) b of
-            Proved Refl -> Proved Refl
-            Disproved contra
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
+        = (\cases
+             (Proved Refl) -> Proved Refl
+             (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b)
+    instance Eq (SConstant (z :: Constant a b)) where
+      (==) _ _ = True
     instance SDecide a =>
-             Data.Type.Equality.TestEquality (SConstant :: Constant a b
-                                                           -> Type) where
-      Data.Type.Equality.testEquality
+             GHC.Internal.Data.Type.Equality.TestEquality (SConstant :: Constant a b
+                                                                        -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
         = Data.Singletons.Decide.decideEquality
     instance SDecide a =>
-             Data.Type.Coercion.TestCoercion (SConstant :: Constant a b
-                                                           -> Type) where
-      Data.Type.Coercion.testCoercion
+             GHC.Internal.Data.Type.Coercion.TestCoercion (SConstant :: Constant a b
+                                                                        -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
         = Data.Singletons.Decide.decideCoercion
     instance SDecide a => SDecide (Identity a) where
       (%~) (SIdentity a) (SIdentity b)
-        = case ((%~) a) b of
-            Proved Refl -> Proved Refl
-            Disproved contra
-              -> Disproved (\ refl -> case refl of Refl -> contra Refl)
+        = (\cases
+             (Proved Refl) -> Proved Refl
+             (Disproved contra) -> Disproved (\cases Refl -> contra Refl))
+            ((%~) a b)
+    instance Eq (SIdentity (z :: Identity a)) where
+      (==) _ _ = True
     instance SDecide a =>
-             Data.Type.Equality.TestEquality (SIdentity :: Identity a
-                                                           -> Type) where
-      Data.Type.Equality.testEquality
+             GHC.Internal.Data.Type.Equality.TestEquality (SIdentity :: Identity a
+                                                                        -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
         = Data.Singletons.Decide.decideEquality
     instance SDecide a =>
-             Data.Type.Coercion.TestCoercion (SIdentity :: Identity a
-                                                           -> Type) where
-      Data.Type.Coercion.testCoercion
+             GHC.Internal.Data.Type.Coercion.TestCoercion (SIdentity :: Identity a
+                                                                        -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
         = Data.Singletons.Decide.decideCoercion
+    instance Ord (SConstant (z :: Constant a b)) where
+      compare _ _ = EQ
+    instance Ord (SIdentity (z :: Identity a)) where
+      compare _ _ = EQ
     instance SingI n => SingI (Constant (n :: a)) where
       sing = SConstant sing
     instance SingI1 Constant where
       liftSing = SConstant
-    instance SingI (ConstantSym0 :: (~>) a (Constant (a :: Type) (b :: Type))) where
-      sing = (singFun1 @ConstantSym0) SConstant
+    instance SingI (ConstantSym0 :: (~>) a (Constant a b)) where
+      sing = singFun1 @ConstantSym0 SConstant
     instance SingI n => SingI (Identity (n :: a)) where
       sing = SIdentity sing
     instance SingI1 Identity where
       liftSing = SIdentity
     instance SingI (IdentitySym0 :: (~>) a (Identity a)) where
-      sing = (singFun1 @IdentitySym0) SIdentity
+      sing = singFun1 @IdentitySym0 SIdentity
diff --git a/tests/compile-and-dump/Singletons/T287.golden b/tests/compile-and-dump/Singletons/T287.golden
--- a/tests/compile-and-dump/Singletons/T287.golden
+++ b/tests/compile-and-dump/Singletons/T287.golden
@@ -15,101 +15,58 @@
       where
         (:<<>>@#@$###) :: SameKind (Apply (<<>>@#@$) arg) ((<<>>@#@$$) arg) =>
                           (<<>>@#@$) a0123456789876543210
-    type instance Apply (<<>>@#@$) a0123456789876543210 = (<<>>@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) a a) (<<>>@#@$) a0123456789876543210 = (<<>>@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (<<>>@#@$) where
-      suppressUnusedWarnings = snd (((,) (:<<>>@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (:<<>>@#@$###) ())
     type (<<>>@#@$$) :: forall a. a -> (~>) a a
     data (<<>>@#@$$) (a0123456789876543210 :: a) :: (~>) a a
       where
         (:<<>>@#@$$###) :: SameKind (Apply ((<<>>@#@$$) a0123456789876543210) arg) ((<<>>@#@$$$) a0123456789876543210 arg) =>
                            (<<>>@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((<<>>@#@$$) a0123456789876543210) a0123456789876543210 = (<<>>) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @a ((<<>>@#@$$) a0123456789876543210) a0123456789876543210 = (<<>>) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((<<>>@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:<<>>@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (:<<>>@#@$$###) ())
     type (<<>>@#@$$$) :: forall a. a -> a -> a
-    type family (<<>>@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
+    type family (<<>>@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
       (<<>>@#@$$$) a0123456789876543210 a0123456789876543210 = (<<>>) a0123456789876543210 a0123456789876543210
     class PS a where
       type family (<<>>) (arg :: a) (arg :: a) :: a
-    type family Lambda_0123456789876543210 f g x where
-      Lambda_0123456789876543210 f g x = Apply (Apply (<<>>@#@$) (Apply f x)) (Apply g x)
-    data Lambda_0123456789876543210Sym0 f0123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 f0123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 f0123456789876543210 = Lambda_0123456789876543210Sym1 f0123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 f0123456789876543210 g0123456789876543210
-      where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 f0123456789876543210) arg) (Lambda_0123456789876543210Sym2 f0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 f0123456789876543210 g0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 f0123456789876543210) g0123456789876543210 = Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 f0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    data Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210 x0123456789876543210
-      where
-        Lambda_0123456789876543210Sym2KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210) arg) (Lambda_0123456789876543210Sym3 f0123456789876543210 g0123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210 f0123456789876543210 g0123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())
-    type family Lambda_0123456789876543210Sym3 f0123456789876543210 g0123456789876543210 x0123456789876543210 where
-      Lambda_0123456789876543210Sym3 f0123456789876543210 g0123456789876543210 x0123456789876543210 = Lambda_0123456789876543210 f0123456789876543210 g0123456789876543210 x0123456789876543210
-    type TFHelper_0123456789876543210 :: (~>) a b
-                                         -> (~>) a b -> (~>) a b
-    type family TFHelper_0123456789876543210 (a :: (~>) a b) (a :: (~>) a b) :: (~>) a b where
-      TFHelper_0123456789876543210 f g = Apply (Apply Lambda_0123456789876543210Sym0 f) g
-    type TFHelper_0123456789876543210Sym0 :: (~>) ((~>) a b) ((~>) ((~>) a b) ((~>) a b))
-    data TFHelper_0123456789876543210Sym0 :: (~>) ((~>) a b) ((~>) ((~>) a b) ((~>) a b))
-      where
-        TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>
-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())
-    type TFHelper_0123456789876543210Sym1 :: (~>) a b
-                                             -> (~>) ((~>) a b) ((~>) a b)
-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a b) :: (~>) ((~>) a b) ((~>) a b)
+    type family LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 (f0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (g0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 a b f g x = Apply (Apply (<<>>@#@$) (Apply f x)) (Apply g x)
+    data LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 (f0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (g0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210
       where
-        TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                         TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 f0123456789876543210 g0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 f0123456789876543210 g0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 f0123456789876543210 g0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 f0123456789876543210 g0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 f0123456789876543210 g0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 b0123456789876543210 f0123456789876543210 g0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())
-    type TFHelper_0123456789876543210Sym2 :: (~>) a b
-                                             -> (~>) a b -> (~>) a b
-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: (~>) a b) :: (~>) a b where
-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 (f0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (g0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210 f0123456789876543210 g0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 b0123456789876543210 f0123456789876543210 g0123456789876543210 a_01234567898765432100123456789876543210
+    type TFHelper_0123456789876543210 :: forall a b. (~>) a b
+                                                     -> (~>) a b -> (~>) a b
+    type family TFHelper_0123456789876543210 @a @b (a :: (~>) a b) (a :: (~>) a b) :: (~>) a b where
+      TFHelper_0123456789876543210 @a @b (f :: (~>) a b) (g :: (~>) a b) = LamCases_0123456789876543210Sym0 a b f g
     instance PS ((~>) a b) where
-      type (<<>>) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
+      type (<<>>) a a = TFHelper_0123456789876543210 a a
     class SS a where
       (%<<>>) ::
-        forall (t :: a) (t :: a). Sing t
-                                  -> Sing t -> Sing (Apply (Apply (<<>>@#@$) t) t :: a)
+        (forall (t :: a) (t :: a).
+         Sing t -> Sing t -> Sing ((<<>>) t t :: a) :: Type)
     instance SS b => SS ((~>) a b) where
-      (%<<>>) ::
-        forall (t :: (~>) a b) (t :: (~>) a b). Sing t
-                                                -> Sing t
-                                                   -> Sing (Apply (Apply (<<>>@#@$) t) t :: (~>) a b)
       (%<<>>) (sF :: Sing f) (sG :: Sing g)
-        = (singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 f) g))
-            (\ sX
-               -> case sX of
-                    (_ :: Sing x)
-                      -> (applySing
-                            ((applySing ((singFun2 @(<<>>@#@$)) (%<<>>))) ((applySing sF) sX)))
-                           ((applySing sG) sX))
+        = singFun1
+            @(LamCases_0123456789876543210Sym0 a b f g)
+            (\cases
+               (sX :: Sing x)
+                 -> applySing
+                      (applySing (singFun2 @(<<>>@#@$) (%<<>>)) (applySing sF sX))
+                      (applySing sG sX))
     instance SS a => SingI ((<<>>@#@$) :: (~>) a ((~>) a a)) where
-      sing = (singFun2 @(<<>>@#@$)) (%<<>>)
+      sing = singFun2 @(<<>>@#@$) (%<<>>)
     instance (SS a, SingI d) =>
              SingI ((<<>>@#@$$) (d :: a) :: (~>) a a) where
-      sing = (singFun1 @((<<>>@#@$$) (d :: a))) ((%<<>>) (sing @d))
+      sing = singFun1 @((<<>>@#@$$) (d :: a)) ((%<<>>) (sing @d))
     instance SS a => SingI1 ((<<>>@#@$$) :: a -> (~>) a a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((<<>>@#@$$) (d :: a))) ((%<<>>) s)
+        = singFun1 @((<<>>@#@$$) (d :: a)) ((%<<>>) s)
diff --git a/tests/compile-and-dump/Singletons/T29.golden b/tests/compile-and-dump/Singletons/T29.golden
--- a/tests/compile-and-dump/Singletons/T29.golden
+++ b/tests/compile-and-dump/Singletons/T29.golden
@@ -22,9 +22,9 @@
       where
         BanSym0KindInference :: SameKind (Apply BanSym0 arg) (BanSym1 arg) =>
                                 BanSym0 a0123456789876543210
-    type instance Apply BanSym0 a0123456789876543210 = Ban a0123456789876543210
+    type instance Apply @Bool @Bool BanSym0 a0123456789876543210 = Ban a0123456789876543210
     instance SuppressUnusedWarnings BanSym0 where
-      suppressUnusedWarnings = snd (((,) BanSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BanSym0KindInference ())
     type BanSym1 :: Bool -> Bool
     type family BanSym1 (a0123456789876543210 :: Bool) :: Bool where
       BanSym1 a0123456789876543210 = Ban a0123456789876543210
@@ -33,9 +33,9 @@
       where
         BazSym0KindInference :: SameKind (Apply BazSym0 arg) (BazSym1 arg) =>
                                 BazSym0 a0123456789876543210
-    type instance Apply BazSym0 a0123456789876543210 = Baz a0123456789876543210
+    type instance Apply @Bool @Bool BazSym0 a0123456789876543210 = Baz a0123456789876543210
     instance SuppressUnusedWarnings BazSym0 where
-      suppressUnusedWarnings = snd (((,) BazSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BazSym0KindInference ())
     type BazSym1 :: Bool -> Bool
     type family BazSym1 (a0123456789876543210 :: Bool) :: Bool where
       BazSym1 a0123456789876543210 = Baz a0123456789876543210
@@ -44,9 +44,9 @@
       where
         BarSym0KindInference :: SameKind (Apply BarSym0 arg) (BarSym1 arg) =>
                                 BarSym0 a0123456789876543210
-    type instance Apply BarSym0 a0123456789876543210 = Bar a0123456789876543210
+    type instance Apply @Bool @Bool BarSym0 a0123456789876543210 = Bar a0123456789876543210
     instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BarSym0KindInference ())
     type BarSym1 :: Bool -> Bool
     type family BarSym1 (a0123456789876543210 :: Bool) :: Bool where
       BarSym1 a0123456789876543210 = Bar a0123456789876543210
@@ -55,9 +55,9 @@
       where
         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
                                 FooSym0 a0123456789876543210
-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210
+    type instance Apply @Bool @Bool FooSym0 a0123456789876543210 = Foo a0123456789876543210
     instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
     type FooSym1 :: Bool -> Bool
     type family FooSym1 (a0123456789876543210 :: Bool) :: Bool where
       FooSym1 a0123456789876543210 = Foo a0123456789876543210
@@ -74,50 +74,44 @@
     type family Foo (a :: Bool) :: Bool where
       Foo x = Apply (Apply ($@#@$) NotSym0) x
     sBan ::
-      forall (t :: Bool). Sing t -> Sing (Apply BanSym0 t :: Bool)
+      (forall (t :: Bool). Sing t -> Sing (Ban t :: Bool) :: Type)
     sBaz ::
-      forall (t :: Bool). Sing t -> Sing (Apply BazSym0 t :: Bool)
+      (forall (t :: Bool). Sing t -> Sing (Baz t :: Bool) :: Type)
     sBar ::
-      forall (t :: Bool). Sing t -> Sing (Apply BarSym0 t :: Bool)
+      (forall (t :: Bool). Sing t -> Sing (Bar t :: Bool) :: Type)
     sFoo ::
-      forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)
+      (forall (t :: Bool). Sing t -> Sing (Foo t :: Bool) :: Type)
     sBan (sX :: Sing x)
-      = (applySing
-           ((applySing ((singFun2 @($!@#@$)) (%$!)))
-              ((applySing
-                  ((applySing ((singFun3 @(.@#@$)) (%.)))
-                     ((singFun1 @NotSym0) sNot)))
-                 ((applySing
-                     ((applySing ((singFun3 @(.@#@$)) (%.)))
-                        ((singFun1 @NotSym0) sNot)))
-                    ((singFun1 @NotSym0) sNot)))))
+      = applySing
+          (applySing
+             (singFun2 @($!@#@$) (%$!))
+             (applySing
+                (applySing (singFun3 @(.@#@$) (%.)) (singFun1 @NotSym0 sNot))
+                (applySing
+                   (applySing (singFun3 @(.@#@$) (%.)) (singFun1 @NotSym0 sNot))
+                   (singFun1 @NotSym0 sNot))))
           sX
     sBaz (sX :: Sing x)
-      = (applySing
-           ((applySing ((singFun2 @($!@#@$)) (%$!)))
-              ((singFun1 @NotSym0) sNot)))
-          sX
+      = applySing
+          (applySing (singFun2 @($!@#@$) (%$!)) (singFun1 @NotSym0 sNot)) sX
     sBar (sX :: Sing x)
-      = (applySing
-           ((applySing ((singFun2 @($@#@$)) (%$)))
-              ((applySing
-                  ((applySing ((singFun3 @(.@#@$)) (%.)))
-                     ((singFun1 @NotSym0) sNot)))
-                 ((applySing
-                     ((applySing ((singFun3 @(.@#@$)) (%.)))
-                        ((singFun1 @NotSym0) sNot)))
-                    ((singFun1 @NotSym0) sNot)))))
+      = applySing
+          (applySing
+             (singFun2 @($@#@$) (%$))
+             (applySing
+                (applySing (singFun3 @(.@#@$) (%.)) (singFun1 @NotSym0 sNot))
+                (applySing
+                   (applySing (singFun3 @(.@#@$) (%.)) (singFun1 @NotSym0 sNot))
+                   (singFun1 @NotSym0 sNot))))
           sX
     sFoo (sX :: Sing x)
-      = (applySing
-           ((applySing ((singFun2 @($@#@$)) (%$)))
-              ((singFun1 @NotSym0) sNot)))
-          sX
+      = applySing
+          (applySing (singFun2 @($@#@$) (%$)) (singFun1 @NotSym0 sNot)) sX
     instance SingI (BanSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @BanSym0) sBan
+      sing = singFun1 @BanSym0 sBan
     instance SingI (BazSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @BazSym0) sBaz
+      sing = singFun1 @BazSym0 sBaz
     instance SingI (BarSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @BarSym0) sBar
+      sing = singFun1 @BarSym0 sBar
     instance SingI (FooSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @FooSym0) sFoo
+      sing = singFun1 @FooSym0 sFoo
diff --git a/tests/compile-and-dump/Singletons/T296.golden b/tests/compile-and-dump/Singletons/T296.golden
--- a/tests/compile-and-dump/Singletons/T296.golden
+++ b/tests/compile-and-dump/Singletons/T296.golden
@@ -20,51 +20,46 @@
                 z = MyProxy
               in z
         in x
-    type MyProxySym0 :: forall (a :: Type). MyProxy (a :: Type)
-    type family MyProxySym0 :: MyProxy (a :: Type) where
+    type MyProxySym0 :: forall (a :: Type). MyProxy a
+    type family MyProxySym0 @(a :: Type) :: MyProxy a where
       MyProxySym0 = MyProxy
-    type Let0123456789876543210ZSym0 :: MyProxy a
-    type family Let0123456789876543210ZSym0 :: MyProxy a where
-      Let0123456789876543210ZSym0 = Let0123456789876543210Z
-    type Let0123456789876543210Z :: MyProxy a
-    type family Let0123456789876543210Z :: MyProxy a where
-      Let0123456789876543210Z = MyProxySym0
-    type family Let0123456789876543210XSym0 where
-      Let0123456789876543210XSym0 = Let0123456789876543210X
-    type family Let0123456789876543210X where
-      Let0123456789876543210X = Let0123456789876543210ZSym0
+    type family Let0123456789876543210ZSym0 a0123456789876543210 :: MyProxy a0123456789876543210 where
+      Let0123456789876543210ZSym0 a0123456789876543210 = Let0123456789876543210Z a0123456789876543210
+    type family Let0123456789876543210Z a0123456789876543210 :: MyProxy a0123456789876543210 where
+      Let0123456789876543210Z a = MyProxySym0
+    type family Let0123456789876543210XSym0 a0123456789876543210 where
+      Let0123456789876543210XSym0 a0123456789876543210 = Let0123456789876543210X a0123456789876543210
+    type family Let0123456789876543210X a0123456789876543210 where
+      Let0123456789876543210X a = Let0123456789876543210ZSym0 a
     type FSym0 :: forall a. (~>) (MyProxy a) (MyProxy a)
     data FSym0 :: (~>) (MyProxy a) (MyProxy a)
       where
         FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
                               FSym0 a0123456789876543210
-    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210
+    type instance Apply @(MyProxy a) @(MyProxy a) FSym0 a0123456789876543210 = F a0123456789876543210
     instance SuppressUnusedWarnings FSym0 where
-      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FSym0KindInference ())
     type FSym1 :: forall a. MyProxy a -> MyProxy a
-    type family FSym1 (a0123456789876543210 :: MyProxy a) :: MyProxy a where
+    type family FSym1 @a (a0123456789876543210 :: MyProxy a) :: MyProxy a where
       FSym1 a0123456789876543210 = F a0123456789876543210
     type F :: forall a. MyProxy a -> MyProxy a
-    type family F (a :: MyProxy a) :: MyProxy a where
-      F MyProxy = Let0123456789876543210XSym0
-    sF ::
-      forall a (t :: MyProxy a). Sing t
-                                 -> Sing (Apply FSym0 t :: MyProxy a)
+    type family F @a (a :: MyProxy a) :: MyProxy a where
+      F @a (MyProxy :: MyProxy a) = Let0123456789876543210XSym0 a
+    sF :: forall a (t :: MyProxy a). Sing t -> Sing (F t :: MyProxy a)
     sF SMyProxy
       = let
-          sX :: Sing @_ Let0123456789876543210XSym0
+          sX :: Sing @_ (Let0123456789876543210X a)
           sX
             = let
-                sZ :: Sing (Let0123456789876543210ZSym0 :: MyProxy a)
+                sZ :: (Sing (Let0123456789876543210Z a :: MyProxy a) :: Type)
                 sZ = SMyProxy
               in sZ
         in sX
     instance SingI (FSym0 :: (~>) (MyProxy a) (MyProxy a)) where
-      sing = (singFun1 @FSym0) sF
+      sing = singFun1 @FSym0 sF
     data SMyProxy :: forall (a :: Type). MyProxy a -> Type
       where
-        SMyProxy :: forall (a :: Type).
-                    SMyProxy (MyProxy :: MyProxy (a :: Type))
+        SMyProxy :: forall (a :: Type). SMyProxy (MyProxy :: MyProxy a)
     type instance Sing @(MyProxy a) = SMyProxy
     instance SingKind a => SingKind (MyProxy a) where
       type Demote (MyProxy a) = MyProxy (Demote a)
diff --git a/tests/compile-and-dump/Singletons/T297.golden b/tests/compile-and-dump/Singletons/T297.golden
--- a/tests/compile-and-dump/Singletons/T297.golden
+++ b/tests/compile-and-dump/Singletons/T297.golden
@@ -18,14 +18,14 @@
                 z = MyProxy
               in z
         in x
-    type MyProxySym0 :: forall (a :: Type). MyProxy (a :: Type)
-    type family MyProxySym0 :: MyProxy (a :: Type) where
+    type MyProxySym0 :: forall (a :: Type). MyProxy a
+    type family MyProxySym0 @(a :: Type) :: MyProxy a where
       MyProxySym0 = MyProxy
     type Let0123456789876543210ZSym0 :: MyProxy a
-    type family Let0123456789876543210ZSym0 :: MyProxy a where
+    type family Let0123456789876543210ZSym0 @a :: MyProxy a where
       Let0123456789876543210ZSym0 = Let0123456789876543210Z
     type Let0123456789876543210Z :: MyProxy a
-    type family Let0123456789876543210Z :: MyProxy a where
+    type family Let0123456789876543210Z @a :: MyProxy a where
       Let0123456789876543210Z = MyProxySym0
     type family Let0123456789876543210XSym0 where
       Let0123456789876543210XSym0 = Let0123456789876543210X
@@ -35,29 +35,28 @@
       where
         FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
                               FSym0 a0123456789876543210
-    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210
+    type instance Apply @_ @_ FSym0 a0123456789876543210 = F a0123456789876543210
     instance SuppressUnusedWarnings FSym0 where
-      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FSym0KindInference ())
     type family FSym1 a0123456789876543210 where
       FSym1 a0123456789876543210 = F a0123456789876543210
     type family F a where
       F MyProxy = Let0123456789876543210XSym0
-    sF :: forall arg. Sing arg -> Sing (Apply FSym0 arg)
+    sF :: forall arg. Sing arg -> Sing (F arg)
     sF SMyProxy
       = let
-          sX :: Sing @_ Let0123456789876543210XSym0
+          sX :: Sing @_ Let0123456789876543210X
           sX
             = let
-                sZ :: forall a. Sing (Let0123456789876543210ZSym0 :: MyProxy a)
+                sZ :: (Sing (Let0123456789876543210Z :: MyProxy a) :: Type)
                 sZ = SMyProxy
               in sZ
         in sX
     instance SingI FSym0 where
-      sing = (singFun1 @FSym0) sF
+      sing = singFun1 @FSym0 sF
     data SMyProxy :: forall (a :: Type). MyProxy a -> Type
       where
-        SMyProxy :: forall (a :: Type).
-                    SMyProxy (MyProxy :: MyProxy (a :: Type))
+        SMyProxy :: forall (a :: Type). SMyProxy (MyProxy :: MyProxy a)
     type instance Sing @(MyProxy a) = SMyProxy
     instance SingKind a => SingKind (MyProxy a) where
       type Demote (MyProxy a) = MyProxy (Demote a)
diff --git a/tests/compile-and-dump/Singletons/T312.golden b/tests/compile-and-dump/Singletons/T312.golden
--- a/tests/compile-and-dump/Singletons/T312.golden
+++ b/tests/compile-and-dump/Singletons/T312.golden
@@ -24,176 +24,115 @@
       where
         BarSym0KindInference :: SameKind (Apply BarSym0 arg) (BarSym1 arg) =>
                                 BarSym0 a0123456789876543210
-    type instance Apply BarSym0 a0123456789876543210 = BarSym1 a0123456789876543210
+    type instance Apply @a @((~>) b b) BarSym0 a0123456789876543210 = BarSym1 a0123456789876543210
     instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BarSym0KindInference ())
     type BarSym1 :: forall a b. a -> (~>) b b
     data BarSym1 (a0123456789876543210 :: a) :: (~>) b b
       where
         BarSym1KindInference :: SameKind (Apply (BarSym1 a0123456789876543210) arg) (BarSym2 a0123456789876543210 arg) =>
                                 BarSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (BarSym1 a0123456789876543210) a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210
+    type instance Apply @b @b (BarSym1 a0123456789876543210) a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (BarSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BarSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) BarSym1KindInference ())
     type BarSym2 :: forall a b. a -> b -> b
-    type family BarSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
+    type family BarSym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
       BarSym2 a0123456789876543210 a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210
     type BazSym0 :: forall a b. (~>) a ((~>) b b)
     data BazSym0 :: (~>) a ((~>) b b)
       where
         BazSym0KindInference :: SameKind (Apply BazSym0 arg) (BazSym1 arg) =>
                                 BazSym0 a0123456789876543210
-    type instance Apply BazSym0 a0123456789876543210 = BazSym1 a0123456789876543210
+    type instance Apply @a @((~>) b b) BazSym0 a0123456789876543210 = BazSym1 a0123456789876543210
     instance SuppressUnusedWarnings BazSym0 where
-      suppressUnusedWarnings = snd (((,) BazSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BazSym0KindInference ())
     type BazSym1 :: forall a b. a -> (~>) b b
     data BazSym1 (a0123456789876543210 :: a) :: (~>) b b
       where
         BazSym1KindInference :: SameKind (Apply (BazSym1 a0123456789876543210) arg) (BazSym2 a0123456789876543210 arg) =>
                                 BazSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (BazSym1 a0123456789876543210) a0123456789876543210 = Baz a0123456789876543210 a0123456789876543210
+    type instance Apply @b @b (BazSym1 a0123456789876543210) a0123456789876543210 = Baz a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (BazSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) BazSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) BazSym1KindInference ())
     type BazSym2 :: forall a b. a -> b -> b
-    type family BazSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
+    type family BazSym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
       BazSym2 a0123456789876543210 a0123456789876543210 = Baz a0123456789876543210 a0123456789876543210
-    type Bar_0123456789876543210 :: a -> b -> b
-    type family Bar_0123456789876543210 (a :: a) (a :: b) :: b where
-      Bar_0123456789876543210 _ x = x
-    type Bar_0123456789876543210Sym0 :: (~>) a ((~>) b b)
-    data Bar_0123456789876543210Sym0 :: (~>) a ((~>) b b)
-      where
-        Bar_0123456789876543210Sym0KindInference :: SameKind (Apply Bar_0123456789876543210Sym0 arg) (Bar_0123456789876543210Sym1 arg) =>
-                                                    Bar_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Bar_0123456789876543210Sym0 a0123456789876543210 = Bar_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Bar_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Bar_0123456789876543210Sym0KindInference) ())
-    type Bar_0123456789876543210Sym1 :: a -> (~>) b b
-    data Bar_0123456789876543210Sym1 (a0123456789876543210 :: a) :: (~>) b b
-      where
-        Bar_0123456789876543210Sym1KindInference :: SameKind (Apply (Bar_0123456789876543210Sym1 a0123456789876543210) arg) (Bar_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                    Bar_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Bar_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Bar_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Bar_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Bar_0123456789876543210Sym1KindInference) ())
-    type Bar_0123456789876543210Sym2 :: a -> b -> b
-    type family Bar_0123456789876543210Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
-      Bar_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Bar_0123456789876543210 a0123456789876543210 a0123456789876543210
-    data Let0123456789876543210HSym0 a_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210HSym0KindInference :: SameKind (Apply Let0123456789876543210HSym0 arg) (Let0123456789876543210HSym1 arg) =>
-                                                    Let0123456789876543210HSym0 a_01234567898765432100123456789876543210
-    type instance Apply Let0123456789876543210HSym0 a_01234567898765432100123456789876543210 = Let0123456789876543210HSym1 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210HSym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210HSym0KindInference) ())
-    data Let0123456789876543210HSym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210HSym1KindInference :: SameKind (Apply (Let0123456789876543210HSym1 a_01234567898765432100123456789876543210) arg) (Let0123456789876543210HSym2 a_01234567898765432100123456789876543210 arg) =>
-                                                    Let0123456789876543210HSym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    type instance Apply (Let0123456789876543210HSym1 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Let0123456789876543210HSym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210HSym1 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210HSym1KindInference) ())
-    data Let0123456789876543210HSym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 :: (~>) c0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)
-      where
-        Let0123456789876543210HSym2KindInference :: SameKind (Apply (Let0123456789876543210HSym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Let0123456789876543210HSym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
-                                                    Let0123456789876543210HSym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210
-    type instance Apply (Let0123456789876543210HSym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a0123456789876543210 = Let0123456789876543210HSym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210HSym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210HSym2KindInference) ())
-    data Let0123456789876543210HSym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 (a0123456789876543210 :: c0123456789876543210) :: (~>) b0123456789876543210 b0123456789876543210
-      where
-        Let0123456789876543210HSym3KindInference :: SameKind (Apply (Let0123456789876543210HSym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210) arg) (Let0123456789876543210HSym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 arg) =>
-                                                    Let0123456789876543210HSym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (Let0123456789876543210HSym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210) a0123456789876543210 = Let0123456789876543210H a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Let0123456789876543210HSym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210HSym3KindInference) ())
-    type family Let0123456789876543210HSym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 (a0123456789876543210 :: c0123456789876543210) (a0123456789876543210 :: b0123456789876543210) :: b0123456789876543210 where
-      Let0123456789876543210HSym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 a0123456789876543210 = Let0123456789876543210H a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 a0123456789876543210
-    type family Let0123456789876543210H a_0123456789876543210 a_0123456789876543210 (a :: c) (a :: b) :: b where
-      Let0123456789876543210H a_0123456789876543210 a_0123456789876543210 _ x = x
-    type Baz_0123456789876543210 :: a -> b -> b
-    type family Baz_0123456789876543210 (a :: a) (a :: b) :: b where
-      Baz_0123456789876543210 a_0123456789876543210 a_0123456789876543210 = Apply (Apply (Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210) a_0123456789876543210
-    type Baz_0123456789876543210Sym0 :: (~>) a ((~>) b b)
-    data Baz_0123456789876543210Sym0 :: (~>) a ((~>) b b)
+    type Bar_0123456789876543210 :: forall a b. a -> b -> b
+    type family Bar_0123456789876543210 @a @b (a :: a) (a :: b) :: b where
+      Bar_0123456789876543210 @a @b (_ :: a) (x :: b) = x
+    data Let0123456789876543210HSym0 a0123456789876543210 b0123456789876543210 (a_01234567898765432100123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) :: (~>) c0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)
       where
-        Baz_0123456789876543210Sym0KindInference :: SameKind (Apply Baz_0123456789876543210Sym0 arg) (Baz_0123456789876543210Sym1 arg) =>
-                                                    Baz_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Baz_0123456789876543210Sym0 a0123456789876543210 = Baz_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings Baz_0123456789876543210Sym0 where
+        Let0123456789876543210HSym0KindInference :: SameKind (Apply (Let0123456789876543210HSym0 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Let0123456789876543210HSym1 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>
+                                                    Let0123456789876543210HSym0 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210
+    type instance Apply @c0123456789876543210 @((~>) b0123456789876543210 b0123456789876543210) (Let0123456789876543210HSym0 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a0123456789876543210 = Let0123456789876543210HSym1 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Let0123456789876543210HSym0 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Baz_0123456789876543210Sym0KindInference) ())
-    type Baz_0123456789876543210Sym1 :: a -> (~>) b b
-    data Baz_0123456789876543210Sym1 (a0123456789876543210 :: a) :: (~>) b b
+        = snd ((,) Let0123456789876543210HSym0KindInference ())
+    data Let0123456789876543210HSym1 a0123456789876543210 b0123456789876543210 (a_01234567898765432100123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) (a0123456789876543210 :: c0123456789876543210) :: (~>) b0123456789876543210 b0123456789876543210
       where
-        Baz_0123456789876543210Sym1KindInference :: SameKind (Apply (Baz_0123456789876543210Sym1 a0123456789876543210) arg) (Baz_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                    Baz_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Baz_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Baz_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (Baz_0123456789876543210Sym1 a0123456789876543210) where
+        Let0123456789876543210HSym1KindInference :: SameKind (Apply (Let0123456789876543210HSym1 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210) arg) (Let0123456789876543210HSym2 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 arg) =>
+                                                    Let0123456789876543210HSym1 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @b0123456789876543210 @b0123456789876543210 (Let0123456789876543210HSym1 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210) a0123456789876543210 = Let0123456789876543210H a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Let0123456789876543210HSym1 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Baz_0123456789876543210Sym1KindInference) ())
-    type Baz_0123456789876543210Sym2 :: a -> b -> b
-    type family Baz_0123456789876543210Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where
-      Baz_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Baz_0123456789876543210 a0123456789876543210 a0123456789876543210
+        = snd ((,) Let0123456789876543210HSym1KindInference ())
+    type family Let0123456789876543210HSym2 a0123456789876543210 b0123456789876543210 (a_01234567898765432100123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) (a0123456789876543210 :: c0123456789876543210) (a0123456789876543210 :: b0123456789876543210) :: b0123456789876543210 where
+      Let0123456789876543210HSym2 a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 a0123456789876543210 = Let0123456789876543210H a0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 a0123456789876543210
+    type family Let0123456789876543210H a0123456789876543210 b0123456789876543210 (a_01234567898765432100123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) (a :: c) (a :: b0123456789876543210) :: b0123456789876543210 where
+      Let0123456789876543210H a b a_0123456789876543210 a_0123456789876543210 (_ :: c) (x :: b) = x
+    type Baz_0123456789876543210 :: forall a b. a -> b -> b
+    type family Baz_0123456789876543210 @a @b (a :: a) (a :: b) :: b where
+      Baz_0123456789876543210 @a @b (a_0123456789876543210 :: a) (a_0123456789876543210 :: b) = Apply (Apply (Let0123456789876543210HSym0 a b a_0123456789876543210 a_0123456789876543210) a_0123456789876543210) a_0123456789876543210
     class PFoo a where
       type family Bar (arg :: a) (arg :: b) :: b
       type family Baz (arg :: a) (arg :: b) :: b
-      type Bar a a = Apply (Apply Bar_0123456789876543210Sym0 a) a
-      type Baz a a = Apply (Apply Baz_0123456789876543210Sym0 a) a
+      type Bar a a = Bar_0123456789876543210 a a
+      type Baz a a = Baz_0123456789876543210 a a
     class SFoo a where
       sBar ::
-        forall b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply BarSym0 t) t :: b)
+        (forall (t :: a) (t :: b).
+         Sing t -> Sing t -> Sing (Bar t t :: b) :: Type)
       sBaz ::
-        forall b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply BazSym0 t) t :: b)
+        forall b (t :: a) (t :: b). Sing t -> Sing t -> Sing (Baz t t :: b)
       default sBar ::
-                forall b (t :: a) (t :: b). ((Apply (Apply BarSym0 t) t :: b)
-                                             ~ Apply (Apply Bar_0123456789876543210Sym0 t) t) =>
-                                            Sing t
-                                            -> Sing t -> Sing (Apply (Apply BarSym0 t) t :: b)
+                (forall (t :: a) (t :: b).
+                 ((Bar t t :: b) ~ Bar_0123456789876543210 t t) =>
+                 Sing t -> Sing t -> Sing (Bar t t :: b) :: Type)
       default sBaz ::
-                forall b (t :: a) (t :: b). ((Apply (Apply BazSym0 t) t :: b)
-                                             ~ Apply (Apply Baz_0123456789876543210Sym0 t) t) =>
-                                            Sing t
-                                            -> Sing t -> Sing (Apply (Apply BazSym0 t) t :: b)
+                forall b (t :: a) (t :: b). ((Baz t t :: b)
+                                             ~ Baz_0123456789876543210 t t) =>
+                                            Sing t -> Sing t -> Sing (Baz t t :: b)
       sBar _ (sX :: Sing x) = sX
       sBaz
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 (let
-                    sH ::
-                      forall c (t :: c) (t :: b). Sing t
-                                                  -> Sing t
-                                                     -> Sing (Apply (Apply (Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210) t) t :: b)
-                    sH _ (sX :: Sing x) = sX
-                  in
-                    (singFun2
-                       @(Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210))
-                      sH))
-                sA_0123456789876543210))
+        = applySing
+            (applySing
+               (let
+                  sH ::
+                    forall c (t :: c) (t :: b). Sing t
+                                                -> Sing t
+                                                   -> Sing (Let0123456789876543210H a b a_0123456789876543210 a_0123456789876543210 t t :: b)
+                  sH _ (sX :: Sing x) = sX
+                in
+                  singFun2
+                    @(Let0123456789876543210HSym0 a b a_0123456789876543210 a_0123456789876543210)
+                    sH)
+               sA_0123456789876543210)
             sA_0123456789876543210
     instance SFoo a => SingI (BarSym0 :: (~>) a ((~>) b b)) where
-      sing = (singFun2 @BarSym0) sBar
+      sing = singFun2 @BarSym0 sBar
     instance (SFoo a, SingI d) =>
              SingI (BarSym1 (d :: a) :: (~>) b b) where
-      sing = (singFun1 @(BarSym1 (d :: a))) (sBar (sing @d))
+      sing = singFun1 @(BarSym1 (d :: a)) (sBar (sing @d))
     instance SFoo a => SingI1 (BarSym1 :: a -> (~>) b b) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(BarSym1 (d :: a))) (sBar s)
+        = singFun1 @(BarSym1 (d :: a)) (sBar s)
     instance SFoo a => SingI (BazSym0 :: (~>) a ((~>) b b)) where
-      sing = (singFun2 @BazSym0) sBaz
+      sing = singFun2 @BazSym0 sBaz
     instance (SFoo a, SingI d) =>
              SingI (BazSym1 (d :: a) :: (~>) b b) where
-      sing = (singFun1 @(BazSym1 (d :: a))) (sBaz (sing @d))
+      sing = singFun1 @(BazSym1 (d :: a)) (sBaz (sing @d))
     instance SFoo a => SingI1 (BazSym1 :: a -> (~>) b b) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(BazSym1 (d :: a))) (sBaz s)
+        = singFun1 @(BazSym1 (d :: a)) (sBaz s)
diff --git a/tests/compile-and-dump/Singletons/T313.golden b/tests/compile-and-dump/Singletons/T313.golden
--- a/tests/compile-and-dump/Singletons/T313.golden
+++ b/tests/compile-and-dump/Singletons/T313.golden
@@ -8,9 +8,9 @@
             type PFoo4 a
             type PFoo4 a = Maybe a
           
-          type instance PFoo2 a = Maybe a
           instance PC a where
-            type PFoo4 a = Maybe a |]
+            type PFoo4 a = Maybe a
+          type instance PFoo2 a = Maybe a |]
   ======>
     type PFoo1 a = Maybe a
     type family PFoo2 a
@@ -26,36 +26,36 @@
       where
         PFoo1Sym0KindInference :: SameKind (Apply PFoo1Sym0 arg) (PFoo1Sym1 arg) =>
                                   PFoo1Sym0 a0123456789876543210
-    type instance Apply PFoo1Sym0 a0123456789876543210 = PFoo1 a0123456789876543210
+    type instance Apply @_ @_ PFoo1Sym0 a0123456789876543210 = PFoo1 a0123456789876543210
     instance SuppressUnusedWarnings PFoo1Sym0 where
-      suppressUnusedWarnings = snd (((,) PFoo1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) PFoo1Sym0KindInference ())
     type family PFoo1Sym1 a0123456789876543210 where
       PFoo1Sym1 a0123456789876543210 = PFoo1 a0123456789876543210
     data PFoo3Sym0 a0123456789876543210
       where
         PFoo3Sym0KindInference :: SameKind (Apply PFoo3Sym0 arg) (PFoo3Sym1 arg) =>
                                   PFoo3Sym0 a0123456789876543210
-    type instance Apply PFoo3Sym0 a0123456789876543210 = PFoo3 a0123456789876543210
+    type instance Apply @_ @_ PFoo3Sym0 a0123456789876543210 = PFoo3 a0123456789876543210
     instance SuppressUnusedWarnings PFoo3Sym0 where
-      suppressUnusedWarnings = snd (((,) PFoo3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) PFoo3Sym0KindInference ())
     type family PFoo3Sym1 a0123456789876543210 where
       PFoo3Sym1 a0123456789876543210 = PFoo3 a0123456789876543210
     data PFoo2Sym0 :: (~>) Type Type
       where
         PFoo2Sym0KindInference :: SameKind (Apply PFoo2Sym0 arg) (PFoo2Sym1 arg) =>
                                   PFoo2Sym0 a0123456789876543210
-    type instance Apply PFoo2Sym0 a0123456789876543210 = PFoo2 a0123456789876543210
+    type instance Apply @Type @Type PFoo2Sym0 a0123456789876543210 = PFoo2 a0123456789876543210
     instance SuppressUnusedWarnings PFoo2Sym0 where
-      suppressUnusedWarnings = snd (((,) PFoo2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) PFoo2Sym0KindInference ())
     type family PFoo2Sym1 (a0123456789876543210 :: Type) :: Type where
       PFoo2Sym1 a0123456789876543210 = PFoo2 a0123456789876543210
     data PFoo4Sym0 a0123456789876543210
       where
         PFoo4Sym0KindInference :: SameKind (Apply PFoo4Sym0 arg) (PFoo4Sym1 arg) =>
                                   PFoo4Sym0 a0123456789876543210
-    type instance Apply PFoo4Sym0 a0123456789876543210 = PFoo4 a0123456789876543210
+    type instance Apply @Type @_ PFoo4Sym0 a0123456789876543210 = PFoo4 a0123456789876543210
     instance SuppressUnusedWarnings PFoo4Sym0 where
-      suppressUnusedWarnings = snd (((,) PFoo4Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) PFoo4Sym0KindInference ())
     type family PFoo4Sym1 (a0123456789876543210 :: Type) where
       PFoo4Sym1 a0123456789876543210 = PFoo4 a0123456789876543210
     class PPC (a :: Type)
@@ -70,9 +70,9 @@
             type SFoo4 a
             type SFoo4 a = Maybe a
           
-          type instance SFoo2 a = Maybe a
           instance SC a where
-            type SFoo4 a = Maybe a |]
+            type SFoo4 a = Maybe a
+          type instance SFoo2 a = Maybe a |]
   ======>
     type SFoo1 a = Maybe a
     type family SFoo2 a
@@ -88,36 +88,36 @@
       where
         SFoo1Sym0KindInference :: SameKind (Apply SFoo1Sym0 arg) (SFoo1Sym1 arg) =>
                                   SFoo1Sym0 a0123456789876543210
-    type instance Apply SFoo1Sym0 a0123456789876543210 = SFoo1 a0123456789876543210
+    type instance Apply @_ @_ SFoo1Sym0 a0123456789876543210 = SFoo1 a0123456789876543210
     instance SuppressUnusedWarnings SFoo1Sym0 where
-      suppressUnusedWarnings = snd (((,) SFoo1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SFoo1Sym0KindInference ())
     type family SFoo1Sym1 a0123456789876543210 where
       SFoo1Sym1 a0123456789876543210 = SFoo1 a0123456789876543210
     data SFoo3Sym0 a0123456789876543210
       where
         SFoo3Sym0KindInference :: SameKind (Apply SFoo3Sym0 arg) (SFoo3Sym1 arg) =>
                                   SFoo3Sym0 a0123456789876543210
-    type instance Apply SFoo3Sym0 a0123456789876543210 = SFoo3 a0123456789876543210
+    type instance Apply @_ @_ SFoo3Sym0 a0123456789876543210 = SFoo3 a0123456789876543210
     instance SuppressUnusedWarnings SFoo3Sym0 where
-      suppressUnusedWarnings = snd (((,) SFoo3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SFoo3Sym0KindInference ())
     type family SFoo3Sym1 a0123456789876543210 where
       SFoo3Sym1 a0123456789876543210 = SFoo3 a0123456789876543210
     data SFoo2Sym0 :: (~>) Type Type
       where
         SFoo2Sym0KindInference :: SameKind (Apply SFoo2Sym0 arg) (SFoo2Sym1 arg) =>
                                   SFoo2Sym0 a0123456789876543210
-    type instance Apply SFoo2Sym0 a0123456789876543210 = SFoo2 a0123456789876543210
+    type instance Apply @Type @Type SFoo2Sym0 a0123456789876543210 = SFoo2 a0123456789876543210
     instance SuppressUnusedWarnings SFoo2Sym0 where
-      suppressUnusedWarnings = snd (((,) SFoo2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SFoo2Sym0KindInference ())
     type family SFoo2Sym1 (a0123456789876543210 :: Type) :: Type where
       SFoo2Sym1 a0123456789876543210 = SFoo2 a0123456789876543210
     data SFoo4Sym0 a0123456789876543210
       where
         SFoo4Sym0KindInference :: SameKind (Apply SFoo4Sym0 arg) (SFoo4Sym1 arg) =>
                                   SFoo4Sym0 a0123456789876543210
-    type instance Apply SFoo4Sym0 a0123456789876543210 = SFoo4 a0123456789876543210
+    type instance Apply @Type @_ SFoo4Sym0 a0123456789876543210 = SFoo4 a0123456789876543210
     instance SuppressUnusedWarnings SFoo4Sym0 where
-      suppressUnusedWarnings = snd (((,) SFoo4Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SFoo4Sym0KindInference ())
     type family SFoo4Sym1 (a0123456789876543210 :: Type) where
       SFoo4Sym1 a0123456789876543210 = SFoo4 a0123456789876543210
     class PSC (a :: Type)
diff --git a/tests/compile-and-dump/Singletons/T316.golden b/tests/compile-and-dump/Singletons/T316.golden
--- a/tests/compile-and-dump/Singletons/T316.golden
+++ b/tests/compile-and-dump/Singletons/T316.golden
@@ -8,35 +8,35 @@
       where
         ReplaceAllGTypesSym0KindInference :: SameKind (Apply ReplaceAllGTypesSym0 arg) (ReplaceAllGTypesSym1 arg) =>
                                              ReplaceAllGTypesSym0 a0123456789876543210
-    type instance Apply ReplaceAllGTypesSym0 a0123456789876543210 = ReplaceAllGTypesSym1 a0123456789876543210
+    type instance Apply @((~>) a ((~>) Type a)) @((~>) [Type] ((~>) [a] [a])) ReplaceAllGTypesSym0 a0123456789876543210 = ReplaceAllGTypesSym1 a0123456789876543210
     instance SuppressUnusedWarnings ReplaceAllGTypesSym0 where
       suppressUnusedWarnings
-        = snd (((,) ReplaceAllGTypesSym0KindInference) ())
+        = snd ((,) ReplaceAllGTypesSym0KindInference ())
     type ReplaceAllGTypesSym1 :: (~>) a ((~>) Type a)
                                  -> (~>) [Type] ((~>) [a] [a])
     data ReplaceAllGTypesSym1 (a0123456789876543210 :: (~>) a ((~>) Type a)) :: (~>) [Type] ((~>) [a] [a])
       where
         ReplaceAllGTypesSym1KindInference :: SameKind (Apply (ReplaceAllGTypesSym1 a0123456789876543210) arg) (ReplaceAllGTypesSym2 a0123456789876543210 arg) =>
                                              ReplaceAllGTypesSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ReplaceAllGTypesSym1 a0123456789876543210) a0123456789876543210 = ReplaceAllGTypesSym2 a0123456789876543210 a0123456789876543210
+    type instance Apply @[Type] @((~>) [a] [a]) (ReplaceAllGTypesSym1 a0123456789876543210) a0123456789876543210 = ReplaceAllGTypesSym2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (ReplaceAllGTypesSym1 a0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) ReplaceAllGTypesSym1KindInference) ())
+        = snd ((,) ReplaceAllGTypesSym1KindInference ())
     type ReplaceAllGTypesSym2 :: (~>) a ((~>) Type a)
                                  -> [Type] -> (~>) [a] [a]
     data ReplaceAllGTypesSym2 (a0123456789876543210 :: (~>) a ((~>) Type a)) (a0123456789876543210 :: [Type]) :: (~>) [a] [a]
       where
         ReplaceAllGTypesSym2KindInference :: SameKind (Apply (ReplaceAllGTypesSym2 a0123456789876543210 a0123456789876543210) arg) (ReplaceAllGTypesSym3 a0123456789876543210 a0123456789876543210 arg) =>
                                              ReplaceAllGTypesSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ReplaceAllGTypesSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ReplaceAllGTypes a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @[a] @[a] (ReplaceAllGTypesSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ReplaceAllGTypes a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (ReplaceAllGTypesSym2 a0123456789876543210 a0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) ReplaceAllGTypesSym2KindInference) ())
+        = snd ((,) ReplaceAllGTypesSym2KindInference ())
     type ReplaceAllGTypesSym3 :: (~>) a ((~>) Type a)
                                  -> [Type] -> [a] -> [a]
-    type family ReplaceAllGTypesSym3 (a0123456789876543210 :: (~>) a ((~>) Type a)) (a0123456789876543210 :: [Type]) (a0123456789876543210 :: [a]) :: [a] where
+    type family ReplaceAllGTypesSym3 @a (a0123456789876543210 :: (~>) a ((~>) Type a)) (a0123456789876543210 :: [Type]) (a0123456789876543210 :: [a]) :: [a] where
       ReplaceAllGTypesSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ReplaceAllGTypes a0123456789876543210 a0123456789876543210 a0123456789876543210
     type ReplaceAllGTypes :: (~>) a ((~>) Type a)
                              -> [Type] -> [a] -> [a]
-    type family ReplaceAllGTypes (a :: (~>) a ((~>) Type a)) (a :: [Type]) (a :: [a]) :: [a] where
+    type family ReplaceAllGTypes @a (a :: (~>) a ((~>) Type a)) (a :: [Type]) (a :: [a]) :: [a] where
       ReplaceAllGTypes f types as = Apply (Apply (Apply ZipWithSym0 f) as) types
diff --git a/tests/compile-and-dump/Singletons/T322.golden b/tests/compile-and-dump/Singletons/T322.golden
--- a/tests/compile-and-dump/Singletons/T322.golden
+++ b/tests/compile-and-dump/Singletons/T322.golden
@@ -13,41 +13,41 @@
       where
         (:!@#@$###) :: SameKind (Apply (!@#@$) arg) ((!@#@$$) arg) =>
                        (!@#@$) a0123456789876543210
-    type instance Apply (!@#@$) a0123456789876543210 = (!@#@$$) a0123456789876543210
+    type instance Apply @Bool @((~>) Bool Bool) (!@#@$) a0123456789876543210 = (!@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (!@#@$) where
-      suppressUnusedWarnings = snd (((,) (:!@#@$###)) ())
-    infixr 2 !@#@$
+      suppressUnusedWarnings = snd ((,) (:!@#@$###) ())
+    infixr 2 type !@#@$
     type (!@#@$$) :: Bool -> (~>) Bool Bool
     data (!@#@$$) (a0123456789876543210 :: Bool) :: (~>) Bool Bool
       where
         (:!@#@$$###) :: SameKind (Apply ((!@#@$$) a0123456789876543210) arg) ((!@#@$$$) a0123456789876543210 arg) =>
                         (!@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((!@#@$$) a0123456789876543210) a0123456789876543210 = (!) a0123456789876543210 a0123456789876543210
+    type instance Apply @Bool @Bool ((!@#@$$) a0123456789876543210) a0123456789876543210 = (!) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((!@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:!@#@$$###)) ())
-    infixr 2 !@#@$$
+      suppressUnusedWarnings = snd ((,) (:!@#@$$###) ())
+    infixr 2 type !@#@$$
     type (!@#@$$$) :: Bool -> Bool -> Bool
     type family (!@#@$$$) (a0123456789876543210 :: Bool) (a0123456789876543210 :: Bool) :: Bool where
       (!@#@$$$) a0123456789876543210 a0123456789876543210 = (!) a0123456789876543210 a0123456789876543210
-    infixr 2 !@#@$$$
+    infixr 2 type !@#@$$$
     type (!) :: Bool -> Bool -> Bool
     type family (!) (a :: Bool) (a :: Bool) :: Bool where
       (!) a_0123456789876543210 a_0123456789876543210 = Apply (Apply (||@#@$) a_0123456789876543210) a_0123456789876543210
-    infixr 2 %!
+    infixr 2 data %!
     (%!) ::
-      forall (t :: Bool) (t :: Bool). Sing t
-                                      -> Sing t -> Sing (Apply (Apply (!@#@$) t) t :: Bool)
+      (forall (t :: Bool) (t :: Bool).
+       Sing t -> Sing t -> Sing ((!) t t :: Bool) :: Type)
     (%!)
       (sA_0123456789876543210 :: Sing a_0123456789876543210)
       (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing
-           ((applySing ((singFun2 @(||@#@$)) (%||))) sA_0123456789876543210))
+      = applySing
+          (applySing (singFun2 @(||@#@$) (%||)) sA_0123456789876543210)
           sA_0123456789876543210
     instance SingI ((!@#@$) :: (~>) Bool ((~>) Bool Bool)) where
-      sing = (singFun2 @(!@#@$)) (%!)
+      sing = singFun2 @(!@#@$) (%!)
     instance SingI d =>
              SingI ((!@#@$$) (d :: Bool) :: (~>) Bool Bool) where
-      sing = (singFun1 @((!@#@$$) (d :: Bool))) ((%!) (sing @d))
+      sing = singFun1 @((!@#@$$) (d :: Bool)) ((%!) (sing @d))
     instance SingI1 ((!@#@$$) :: Bool -> (~>) Bool Bool) where
       liftSing (s :: Sing (d :: Bool))
-        = (singFun1 @((!@#@$$) (d :: Bool))) ((%!) s)
+        = singFun1 @((!@#@$$) (d :: Bool)) ((%!) s)
diff --git a/tests/compile-and-dump/Singletons/T326.golden b/tests/compile-and-dump/Singletons/T326.golden
--- a/tests/compile-and-dump/Singletons/T326.golden
+++ b/tests/compile-and-dump/Singletons/T326.golden
@@ -1,72 +1,72 @@
 Singletons/T326.hs:0:0:: Splicing declarations
     genPromotions [''C1]
   ======>
-    type (<%>@#@$) :: forall a. (~>) a ((~>) a a)
+    type (<%>@#@$) :: forall (a :: Type). (~>) a ((~>) a a)
     data (<%>@#@$) :: (~>) a ((~>) a a)
       where
         (:<%>@#@$###) :: SameKind (Apply (<%>@#@$) arg) ((<%>@#@$$) arg) =>
                          (<%>@#@$) a0123456789876543210
-    type instance Apply (<%>@#@$) a0123456789876543210 = (<%>@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) a a) (<%>@#@$) a0123456789876543210 = (<%>@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (<%>@#@$) where
-      suppressUnusedWarnings = snd (((,) (:<%>@#@$###)) ())
-    infixl 9 <%>@#@$
-    type (<%>@#@$$) :: forall a. a -> (~>) a a
+      suppressUnusedWarnings = snd ((,) (:<%>@#@$###) ())
+    infixl 9 type <%>@#@$
+    type (<%>@#@$$) :: forall (a :: Type). a -> (~>) a a
     data (<%>@#@$$) (a0123456789876543210 :: a) :: (~>) a a
       where
         (:<%>@#@$$###) :: SameKind (Apply ((<%>@#@$$) a0123456789876543210) arg) ((<%>@#@$$$) a0123456789876543210 arg) =>
                           (<%>@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((<%>@#@$$) a0123456789876543210) a0123456789876543210 = (<%>) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @a ((<%>@#@$$) a0123456789876543210) a0123456789876543210 = (<%>) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((<%>@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:<%>@#@$$###)) ())
-    infixl 9 <%>@#@$$
-    type (<%>@#@$$$) :: forall a. a -> a -> a
-    type family (<%>@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
+      suppressUnusedWarnings = snd ((,) (:<%>@#@$$###) ())
+    infixl 9 type <%>@#@$$
+    type (<%>@#@$$$) :: forall (a :: Type). a -> a -> a
+    type family (<%>@#@$$$) @(a :: Type) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
       (<%>@#@$$$) a0123456789876543210 a0123456789876543210 = (<%>) a0123456789876543210 a0123456789876543210
-    infixl 9 <%>@#@$$$
+    infixl 9 type <%>@#@$$$
     type PC1 :: Type -> Constraint
     class PC1 (a :: Type) where
       type family (<%>) (arg :: a) (arg :: a) :: a
-    infixl 9 <%>
+    infixl 9 type <%>
 Singletons/T326.hs:0:0:: Splicing declarations
     genSingletons [''C2]
   ======>
-    type (<%%>@#@$) :: forall a. (~>) a ((~>) a a)
+    type (<%%>@#@$) :: forall (a :: Type). (~>) a ((~>) a a)
     data (<%%>@#@$) :: (~>) a ((~>) a a)
       where
         (:<%%>@#@$###) :: SameKind (Apply (<%%>@#@$) arg) ((<%%>@#@$$) arg) =>
                           (<%%>@#@$) a0123456789876543210
-    type instance Apply (<%%>@#@$) a0123456789876543210 = (<%%>@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) a a) (<%%>@#@$) a0123456789876543210 = (<%%>@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (<%%>@#@$) where
-      suppressUnusedWarnings = snd (((,) (:<%%>@#@$###)) ())
-    infixl 9 <%%>@#@$
-    type (<%%>@#@$$) :: forall a. a -> (~>) a a
+      suppressUnusedWarnings = snd ((,) (:<%%>@#@$###) ())
+    infixl 9 type <%%>@#@$
+    type (<%%>@#@$$) :: forall (a :: Type). a -> (~>) a a
     data (<%%>@#@$$) (a0123456789876543210 :: a) :: (~>) a a
       where
         (:<%%>@#@$$###) :: SameKind (Apply ((<%%>@#@$$) a0123456789876543210) arg) ((<%%>@#@$$$) a0123456789876543210 arg) =>
                            (<%%>@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((<%%>@#@$$) a0123456789876543210) a0123456789876543210 = (<%%>) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @a ((<%%>@#@$$) a0123456789876543210) a0123456789876543210 = (<%%>) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((<%%>@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (:<%%>@#@$$###)) ())
-    infixl 9 <%%>@#@$$
-    type (<%%>@#@$$$) :: forall a. a -> a -> a
-    type family (<%%>@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
+      suppressUnusedWarnings = snd ((,) (:<%%>@#@$$###) ())
+    infixl 9 type <%%>@#@$$
+    type (<%%>@#@$$$) :: forall (a :: Type). a -> a -> a
+    type family (<%%>@#@$$$) @(a :: Type) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
       (<%%>@#@$$$) a0123456789876543210 a0123456789876543210 = (<%%>) a0123456789876543210 a0123456789876543210
-    infixl 9 <%%>@#@$$$
+    infixl 9 type <%%>@#@$$$
     type PC2 :: Type -> Constraint
     class PC2 (a :: Type) where
       type family (<%%>) (arg :: a) (arg :: a) :: a
-    infixl 9 <%%>
+    infixl 9 type <%%>
     class SC2 (a :: Type) where
       (%<%%>) ::
-        forall (t :: a) (t :: a). Sing t
-                                  -> Sing t -> Sing (Apply (Apply (<%%>@#@$) t) t :: a)
+        (forall (t :: a) (t :: a).
+         Sing t -> Sing t -> Sing ((<%%>) t t :: a) :: Type)
     type SC2 :: Type -> Constraint
-    infixl 9 %<%%>
+    infixl 9 data %<%%>
     instance SC2 a => SingI ((<%%>@#@$) :: (~>) a ((~>) a a)) where
-      sing = (singFun2 @(<%%>@#@$)) (%<%%>)
+      sing = singFun2 @(<%%>@#@$) (%<%%>)
     instance (SC2 a, SingI d) =>
              SingI ((<%%>@#@$$) (d :: a) :: (~>) a a) where
-      sing = (singFun1 @((<%%>@#@$$) (d :: a))) ((%<%%>) (sing @d))
+      sing = singFun1 @((<%%>@#@$$) (d :: a)) ((%<%%>) (sing @d))
     instance SC2 a => SingI1 ((<%%>@#@$$) :: a -> (~>) a a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((<%%>@#@$$) (d :: a))) ((%<%%>) s)
+        = singFun1 @((<%%>@#@$$) (d :: a)) ((%<%%>) s)
diff --git a/tests/compile-and-dump/Singletons/T33.golden b/tests/compile-and-dump/Singletons/T33.golden
--- a/tests/compile-and-dump/Singletons/T33.golden
+++ b/tests/compile-and-dump/Singletons/T33.golden
@@ -10,9 +10,10 @@
       where
         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
                                 FooSym0 a0123456789876543210
-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210
+    type instance Apply @(Bool,
+                          Bool) @() FooSym0 a0123456789876543210 = Foo a0123456789876543210
     instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
     type FooSym1 :: (Bool, Bool) -> ()
     type family FooSym1 (a0123456789876543210 :: (Bool,
                                                   Bool)) :: () where
@@ -21,19 +22,19 @@
     type family Foo (a :: (Bool, Bool)) :: () where
       Foo '(_, _) = Tuple0Sym0
     sFoo ::
-      forall (t :: (Bool, Bool)). Sing t -> Sing (Apply FooSym0 t :: ())
+      (forall (t :: (Bool, Bool)). Sing t -> Sing (Foo t :: ()) :: Type)
     sFoo (STuple2 _ _) = STuple0
     instance SingI (FooSym0 :: (~>) (Bool, Bool) ()) where
-      sing = (singFun1 @FooSym0) sFoo
-
-Singletons/T33.hs:0:0: warning:
+      sing = singFun1 @FooSym0 sFoo
+Singletons/T33.hs:0:0: warning: [GHC-39584]
     Lazy pattern converted into regular pattern during singleton generation.
   |
 6 | $(singletons [d|
   |  ^^^^^^^^^^^^^^^...
 
-Singletons/T33.hs:0:0: warning:
+Singletons/T33.hs:0:0: warning: [GHC-39584]
     Lazy pattern converted into regular pattern in promotion
   |
 6 | $(singletons [d|
   |  ^^^^^^^^^^^^^^^...
+
diff --git a/tests/compile-and-dump/Singletons/T332.golden b/tests/compile-and-dump/Singletons/T332.golden
--- a/tests/compile-and-dump/Singletons/T332.golden
+++ b/tests/compile-and-dump/Singletons/T332.golden
@@ -16,9 +16,9 @@
       where
         FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
                               FSym0 a0123456789876543210
-    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210
+    type instance Apply @Foo @() FSym0 a0123456789876543210 = F a0123456789876543210
     instance SuppressUnusedWarnings FSym0 where
-      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FSym0KindInference ())
     type FSym1 :: Foo -> ()
     type family FSym1 (a0123456789876543210 :: Foo) :: () where
       FSym1 a0123456789876543210 = F a0123456789876543210
@@ -43,19 +43,19 @@
       where
         BSym0KindInference :: SameKind (Apply BSym0 arg) (BSym1 arg) =>
                               BSym0 a0123456789876543210
-    type instance Apply BSym0 a0123456789876543210 = B a0123456789876543210
+    type instance Apply @Bar @() BSym0 a0123456789876543210 = B a0123456789876543210
     instance SuppressUnusedWarnings BSym0 where
-      suppressUnusedWarnings = snd (((,) BSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BSym0KindInference ())
     type BSym1 :: Bar -> ()
     type family BSym1 (a0123456789876543210 :: Bar) :: () where
       BSym1 a0123456789876543210 = B a0123456789876543210
     type B :: Bar -> ()
     type family B (a :: Bar) :: () where
       B MkBar = Tuple0Sym0
-    sB :: forall (t :: Bar). Sing t -> Sing (Apply BSym0 t :: ())
+    sB :: (forall (t :: Bar). Sing t -> Sing (B t :: ()) :: Type)
     sB SMkBar = STuple0
     instance SingI (BSym0 :: (~>) Bar ()) where
-      sing = (singFun1 @BSym0) sB
+      sing = singFun1 @BSym0 sB
     data SBar :: Bar -> Type where SMkBar :: SBar (MkBar :: Bar)
     type instance Sing @Bar = SBar
     instance SingKind Bar where
diff --git a/tests/compile-and-dump/Singletons/T342.golden b/tests/compile-and-dump/Singletons/T342.golden
--- a/tests/compile-and-dump/Singletons/T342.golden
+++ b/tests/compile-and-dump/Singletons/T342.golden
@@ -1,7 +1,7 @@
 Singletons/T342.hs:(0,0)-(0,0): Splicing declarations
     do synName <- newName "MyId"
        a <- newName "a"
-       let dsyn = DTySynD synName [DPlainTV a ()] (DVarT a)
+       let dsyn = DTySynD synName [DPlainTV a BndrReq] (DVarT a)
            syn = decToTH dsyn
        defuns <- withLocalDeclarations [syn] $ genDefunSymbols [synName]
        pure $ syn : defuns
@@ -11,8 +11,8 @@
       where
         MyIdSym0KindInference :: SameKind (Apply MyIdSym0 arg) (MyIdSym1 arg) =>
                                  MyIdSym0 a0123456789876543210
-    type instance Apply MyIdSym0 a0123456789876543210 = MyId a0123456789876543210
+    type instance Apply @_ @_ MyIdSym0 a0123456789876543210 = MyId a0123456789876543210
     instance SuppressUnusedWarnings MyIdSym0 where
-      suppressUnusedWarnings = snd (((,) MyIdSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MyIdSym0KindInference ())
     type family MyIdSym1 a0123456789876543210 where
       MyIdSym1 a0123456789876543210 = MyId a0123456789876543210
diff --git a/tests/compile-and-dump/Singletons/T342.hs b/tests/compile-and-dump/Singletons/T342.hs
--- a/tests/compile-and-dump/Singletons/T342.hs
+++ b/tests/compile-and-dump/Singletons/T342.hs
@@ -6,7 +6,7 @@
 
 $(do synName <- newName "MyId"
      a       <- newName "a"
-     let dsyn = DTySynD synName [DPlainTV a ()] (DVarT a)
+     let dsyn = DTySynD synName [DPlainTV a BndrReq] (DVarT a)
          syn  = decToTH dsyn
      defuns <- withLocalDeclarations [syn] $
                genDefunSymbols [synName]
diff --git a/tests/compile-and-dump/Singletons/T353.golden b/tests/compile-and-dump/Singletons/T353.golden
--- a/tests/compile-and-dump/Singletons/T353.golden
+++ b/tests/compile-and-dump/Singletons/T353.golden
@@ -11,89 +11,85 @@
       where
         SymmetrySym0KindInference :: SameKind (Apply SymmetrySym0 arg) (SymmetrySym1 arg) =>
                                      SymmetrySym0 a0123456789876543210
-    type instance Apply SymmetrySym0 a0123456789876543210 = SymmetrySym1 a0123456789876543210
+    type instance Apply @(Proxy t0123456789876543210) @((~>) (Proxy t0123456789876543210) ((~>) ((:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) Type)) SymmetrySym0 a0123456789876543210 = SymmetrySym1 a0123456789876543210
     instance SuppressUnusedWarnings SymmetrySym0 where
-      suppressUnusedWarnings = snd (((,) SymmetrySym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SymmetrySym0KindInference ())
     data SymmetrySym1 (a0123456789876543210 :: Proxy t0123456789876543210) :: (~>) (Proxy t0123456789876543210) ((~>) ((:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) Type)
       where
         SymmetrySym1KindInference :: SameKind (Apply (SymmetrySym1 a0123456789876543210) arg) (SymmetrySym2 a0123456789876543210 arg) =>
                                      SymmetrySym1 a0123456789876543210 y0123456789876543210
-    type instance Apply (SymmetrySym1 a0123456789876543210) y0123456789876543210 = SymmetrySym2 a0123456789876543210 y0123456789876543210
+    type instance Apply @(Proxy t0123456789876543210) @((~>) ((:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) Type) (SymmetrySym1 a0123456789876543210) y0123456789876543210 = SymmetrySym2 a0123456789876543210 y0123456789876543210
     instance SuppressUnusedWarnings (SymmetrySym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) SymmetrySym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) SymmetrySym1KindInference ())
     data SymmetrySym2 (a0123456789876543210 :: Proxy t0123456789876543210) (y0123456789876543210 :: Proxy t0123456789876543210) :: (~>) ((:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) Type
       where
         SymmetrySym2KindInference :: SameKind (Apply (SymmetrySym2 a0123456789876543210 y0123456789876543210) arg) (SymmetrySym3 a0123456789876543210 y0123456789876543210 arg) =>
                                      SymmetrySym2 a0123456789876543210 y0123456789876543210 e0123456789876543210
-    type instance Apply (SymmetrySym2 a0123456789876543210 y0123456789876543210) e0123456789876543210 = Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210
+    type instance Apply @((:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) @Type (SymmetrySym2 a0123456789876543210 y0123456789876543210) e0123456789876543210 = Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210
     instance SuppressUnusedWarnings (SymmetrySym2 a0123456789876543210 y0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) SymmetrySym2KindInference) ())
+      suppressUnusedWarnings = snd ((,) SymmetrySym2KindInference ())
     type family SymmetrySym3 (a0123456789876543210 :: Proxy t0123456789876543210) (y0123456789876543210 :: Proxy t0123456789876543210) (e0123456789876543210 :: (:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) :: Type where
       SymmetrySym3 a0123456789876543210 y0123456789876543210 e0123456789876543210 = Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210
 Singletons/T353.hs:0:0:: Splicing declarations
     genDefunSymbols [''Prod]
   ======>
-    type MkProdSym0 :: forall k
+    type MkProdSym0 :: forall {k :: Type}
                               (f :: k -> Type)
                               (g :: k -> Type)
-                              (p :: k). (~>) (f p) ((~>) (g p) (Prod (f :: k -> Type) (g :: k
-                                                                                            -> Type) (p :: k)))
-    data MkProdSym0 :: (~>) (f p) ((~>) (g p) (Prod (f :: k
-                                                          -> Type) (g :: k -> Type) (p :: k)))
+                              (p :: k). (~>) (f p) ((~>) (g p) (Prod f g p))
+    data MkProdSym0 :: (~>) (f p) ((~>) (g p) (Prod f g p))
       where
         MkProdSym0KindInference :: SameKind (Apply MkProdSym0 arg) (MkProdSym1 arg) =>
                                    MkProdSym0 a0123456789876543210
-    type instance Apply MkProdSym0 a0123456789876543210 = MkProdSym1 a0123456789876543210
+    type instance Apply @(f p) @((~>) (g p) (Prod f g p)) MkProdSym0 a0123456789876543210 = MkProdSym1 a0123456789876543210
     instance SuppressUnusedWarnings MkProdSym0 where
-      suppressUnusedWarnings = snd (((,) MkProdSym0KindInference) ())
-    type MkProdSym1 :: forall k
+      suppressUnusedWarnings = snd ((,) MkProdSym0KindInference ())
+    type MkProdSym1 :: forall {k :: Type}
                               (f :: k -> Type)
                               (g :: k -> Type)
-                              (p :: k). f p
-                                        -> (~>) (g p) (Prod (f :: k -> Type) (g :: k
-                                                                                   -> Type) (p :: k))
-    data MkProdSym1 (a0123456789876543210 :: f p) :: (~>) (g p) (Prod (f :: k
-                                                                            -> Type) (g :: k
-                                                                                           -> Type) (p :: k))
+                              (p :: k). f p -> (~>) (g p) (Prod f g p)
+    data MkProdSym1 (a0123456789876543210 :: f p) :: (~>) (g p) (Prod f g p)
       where
         MkProdSym1KindInference :: SameKind (Apply (MkProdSym1 a0123456789876543210) arg) (MkProdSym2 a0123456789876543210 arg) =>
                                    MkProdSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkProdSym1 a0123456789876543210) a0123456789876543210 = 'MkProd a0123456789876543210 a0123456789876543210
+    type instance Apply @(g p) @(Prod f g p) (MkProdSym1 a0123456789876543210) a0123456789876543210 = 'MkProd a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MkProdSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkProdSym1KindInference) ())
-    type MkProdSym2 :: forall k
+      suppressUnusedWarnings = snd ((,) MkProdSym1KindInference ())
+    type MkProdSym2 :: forall {k :: Type}
                               (f :: k -> Type)
                               (g :: k -> Type)
-                              (p :: k). f p
-                                        -> g p -> Prod (f :: k -> Type) (g :: k -> Type) (p :: k)
-    type family MkProdSym2 (a0123456789876543210 :: f p) (a0123456789876543210 :: g p) :: Prod (f :: k
-                                                                                                     -> Type) (g :: k
-                                                                                                                    -> Type) (p :: k) where
+                              (p :: k). f p -> g p -> Prod f g p
+    type family MkProdSym2 @(f :: k -> Type) @(g :: k
+                                                    -> Type) @(p :: k) (a0123456789876543210 :: f p) (a0123456789876543210 :: g p) :: Prod f g p where
       MkProdSym2 a0123456789876543210 a0123456789876543210 = 'MkProd a0123456789876543210 a0123456789876543210
 Singletons/T353.hs:0:0:: Splicing declarations
     genDefunSymbols [''Foo]
   ======>
-    type MkFooSym0 :: forall k
-                             k
+    type MkFooSym0 :: forall {k :: Type}
+                             {k :: Type}
                              (a :: k)
-                             (b :: k). (~>) (Proxy a) ((~>) (Proxy b) (Foo (a :: k) (b :: k)))
-    data MkFooSym0 :: (~>) (Proxy a) ((~>) (Proxy b) (Foo (a :: k) (b :: k)))
+                             (b :: k). (~>) (Proxy a) ((~>) (Proxy b) (Foo a b))
+    data MkFooSym0 :: (~>) (Proxy a) ((~>) (Proxy b) (Foo a b))
       where
         MkFooSym0KindInference :: SameKind (Apply MkFooSym0 arg) (MkFooSym1 arg) =>
                                   MkFooSym0 a0123456789876543210
-    type instance Apply MkFooSym0 a0123456789876543210 = MkFooSym1 a0123456789876543210
+    type instance Apply @(Proxy a) @((~>) (Proxy b) (Foo a b)) MkFooSym0 a0123456789876543210 = MkFooSym1 a0123456789876543210
     instance SuppressUnusedWarnings MkFooSym0 where
-      suppressUnusedWarnings = snd (((,) MkFooSym0KindInference) ())
-    type MkFooSym1 :: forall k k (a :: k) (b :: k). Proxy a
-                                                    -> (~>) (Proxy b) (Foo (a :: k) (b :: k))
-    data MkFooSym1 (a0123456789876543210 :: Proxy a) :: (~>) (Proxy b) (Foo (a :: k) (b :: k))
+      suppressUnusedWarnings = snd ((,) MkFooSym0KindInference ())
+    type MkFooSym1 :: forall {k :: Type}
+                             {k :: Type}
+                             (a :: k)
+                             (b :: k). Proxy a -> (~>) (Proxy b) (Foo a b)
+    data MkFooSym1 (a0123456789876543210 :: Proxy a) :: (~>) (Proxy b) (Foo a b)
       where
         MkFooSym1KindInference :: SameKind (Apply (MkFooSym1 a0123456789876543210) arg) (MkFooSym2 a0123456789876543210 arg) =>
                                   MkFooSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkFooSym1 a0123456789876543210) a0123456789876543210 = 'MkFoo a0123456789876543210 a0123456789876543210
+    type instance Apply @(Proxy b) @(Foo a b) (MkFooSym1 a0123456789876543210) a0123456789876543210 = 'MkFoo a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MkFooSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkFooSym1KindInference) ())
-    type MkFooSym2 :: forall k k (a :: k) (b :: k). Proxy a
-                                                    -> Proxy b -> Foo (a :: k) (b :: k)
-    type family MkFooSym2 (a0123456789876543210 :: Proxy a) (a0123456789876543210 :: Proxy b) :: Foo (a :: k) (b :: k) where
+      suppressUnusedWarnings = snd ((,) MkFooSym1KindInference ())
+    type MkFooSym2 :: forall {k :: Type}
+                             {k :: Type}
+                             (a :: k)
+                             (b :: k). Proxy a -> Proxy b -> Foo a b
+    type family MkFooSym2 @(a :: k) @(b :: k) (a0123456789876543210 :: Proxy a) (a0123456789876543210 :: Proxy b) :: Foo a b where
       MkFooSym2 a0123456789876543210 a0123456789876543210 = 'MkFoo a0123456789876543210 a0123456789876543210
diff --git a/tests/compile-and-dump/Singletons/T358.golden b/tests/compile-and-dump/Singletons/T358.golden
--- a/tests/compile-and-dump/Singletons/T358.golden
+++ b/tests/compile-and-dump/Singletons/T358.golden
@@ -5,13 +5,13 @@
           class C2 a where
             method2a, method2b :: forall b. b -> a
           
-          instance C1 [] where
-            method1 :: [a]
-            method1 = []
           instance C2 [a] where
             method2a _ = []
             method2b :: forall b. b -> [a]
-            method2b _ = [] |]
+            method2b _ = []
+          instance C1 [] where
+            method1 :: [a]
+            method1 = [] |]
   ======>
     class C1 (f :: k -> Type) where
       method1 :: f a
@@ -26,7 +26,7 @@
       method2a _ = []
       method2b _ = []
     type Method1Sym0 :: forall f a. f a
-    type family Method1Sym0 :: f a where
+    type family Method1Sym0 @f @a :: f a where
       Method1Sym0 = Method1
     class PC1 (f :: k -> Type) where
       type family Method1 :: f a
@@ -35,85 +35,53 @@
       where
         Method2aSym0KindInference :: SameKind (Apply Method2aSym0 arg) (Method2aSym1 arg) =>
                                      Method2aSym0 a0123456789876543210
-    type instance Apply Method2aSym0 a0123456789876543210 = Method2a a0123456789876543210
+    type instance Apply @b @a Method2aSym0 a0123456789876543210 = Method2a a0123456789876543210
     instance SuppressUnusedWarnings Method2aSym0 where
-      suppressUnusedWarnings = snd (((,) Method2aSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Method2aSym0KindInference ())
     type Method2aSym1 :: forall b a. b -> a
-    type family Method2aSym1 (a0123456789876543210 :: b) :: a where
+    type family Method2aSym1 @b @a (a0123456789876543210 :: b) :: a where
       Method2aSym1 a0123456789876543210 = Method2a a0123456789876543210
     type Method2bSym0 :: forall b a. (~>) b a
     data Method2bSym0 :: (~>) b a
       where
         Method2bSym0KindInference :: SameKind (Apply Method2bSym0 arg) (Method2bSym1 arg) =>
                                      Method2bSym0 a0123456789876543210
-    type instance Apply Method2bSym0 a0123456789876543210 = Method2b a0123456789876543210
+    type instance Apply @b @a Method2bSym0 a0123456789876543210 = Method2b a0123456789876543210
     instance SuppressUnusedWarnings Method2bSym0 where
-      suppressUnusedWarnings = snd (((,) Method2bSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) Method2bSym0KindInference ())
     type Method2bSym1 :: forall b a. b -> a
-    type family Method2bSym1 (a0123456789876543210 :: b) :: a where
+    type family Method2bSym1 @b @a (a0123456789876543210 :: b) :: a where
       Method2bSym1 a0123456789876543210 = Method2b a0123456789876543210
     class PC2 a where
       type family Method2a (arg :: b) :: a
       type family Method2b (arg :: b) :: a
-    type Method1_0123456789876543210 :: [a]
-    type family Method1_0123456789876543210 :: [a] where
-      Method1_0123456789876543210 = NilSym0
-    type Method1_0123456789876543210Sym0 :: [a]
-    type family Method1_0123456789876543210Sym0 :: [a] where
-      Method1_0123456789876543210Sym0 = Method1_0123456789876543210
+    type Method1_0123456789876543210 :: forall a. [a]
+    type family Method1_0123456789876543210 @a :: [a] where
+      Method1_0123456789876543210 @a = NilSym0
     instance PC1 [] where
-      type Method1 = Method1_0123456789876543210Sym0
-    type Method2a_0123456789876543210 :: b -> [a]
-    type family Method2a_0123456789876543210 (a :: b) :: [a] where
-      Method2a_0123456789876543210 _ = NilSym0
-    type Method2a_0123456789876543210Sym0 :: (~>) b [a]
-    data Method2a_0123456789876543210Sym0 :: (~>) b [a]
-      where
-        Method2a_0123456789876543210Sym0KindInference :: SameKind (Apply Method2a_0123456789876543210Sym0 arg) (Method2a_0123456789876543210Sym1 arg) =>
-                                                         Method2a_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Method2a_0123456789876543210Sym0 a0123456789876543210 = Method2a_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings Method2a_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Method2a_0123456789876543210Sym0KindInference) ())
-    type Method2a_0123456789876543210Sym1 :: b -> [a]
-    type family Method2a_0123456789876543210Sym1 (a0123456789876543210 :: b) :: [a] where
-      Method2a_0123456789876543210Sym1 a0123456789876543210 = Method2a_0123456789876543210 a0123456789876543210
-    type Method2b_0123456789876543210 :: b -> [a]
-    type family Method2b_0123456789876543210 (a :: b) :: [a] where
-      Method2b_0123456789876543210 _ = NilSym0
-    type Method2b_0123456789876543210Sym0 :: (~>) b [a]
-    data Method2b_0123456789876543210Sym0 :: (~>) b [a]
-      where
-        Method2b_0123456789876543210Sym0KindInference :: SameKind (Apply Method2b_0123456789876543210Sym0 arg) (Method2b_0123456789876543210Sym1 arg) =>
-                                                         Method2b_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Method2b_0123456789876543210Sym0 a0123456789876543210 = Method2b_0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings Method2b_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Method2b_0123456789876543210Sym0KindInference) ())
-    type Method2b_0123456789876543210Sym1 :: b -> [a]
-    type family Method2b_0123456789876543210Sym1 (a0123456789876543210 :: b) :: [a] where
-      Method2b_0123456789876543210Sym1 a0123456789876543210 = Method2b_0123456789876543210 a0123456789876543210
+      type Method1 = Method1_0123456789876543210
+    type Method2a_0123456789876543210 :: forall a b. b -> [a]
+    type family Method2a_0123456789876543210 @a @b (a :: b) :: [a] where
+      Method2a_0123456789876543210 @a @b (_ :: b) = NilSym0
+    type Method2b_0123456789876543210 :: forall a b. b -> [a]
+    type family Method2b_0123456789876543210 @a @b (a :: b) :: [a] where
+      Method2b_0123456789876543210 @a @b (_ :: b) = NilSym0
     instance PC2 [a] where
-      type Method2a a = Apply Method2a_0123456789876543210Sym0 a
-      type Method2b a = Apply Method2b_0123456789876543210Sym0 a
+      type Method2a a = Method2a_0123456789876543210 a
+      type Method2b a = Method2b_0123456789876543210 a
     class SC1 (f :: k -> Type) where
-      sMethod1 :: forall a. Sing (Method1Sym0 :: f a)
+      sMethod1 :: (Sing (Method1 :: f a) :: Type)
     class SC2 a where
-      sMethod2a ::
-        forall b (t :: b). Sing t -> Sing (Apply Method2aSym0 t :: a)
-      sMethod2b ::
-        forall b (t :: b). Sing t -> Sing (Apply Method2bSym0 t :: a)
+      sMethod2a :: forall b (t :: b). Sing t -> Sing (Method2a t :: a)
+      sMethod2b :: forall b (t :: b). Sing t -> Sing (Method2b t :: a)
     instance SC1 [] where
-      sMethod1 :: forall a. Sing (Method1Sym0 :: [a])
+      sMethod1 :: (Sing (Method1 :: [a]) :: Type)
       sMethod1 = SNil
     instance SC2 [a] where
-      sMethod2a ::
-        forall b (t :: b). Sing t -> Sing (Apply Method2aSym0 t :: [a])
-      sMethod2b ::
-        forall b (t :: b). Sing t -> Sing (Apply Method2bSym0 t :: [a])
+      sMethod2b :: forall b (t :: b). Sing t -> Sing (Method2b t :: [a])
       sMethod2a _ = SNil
       sMethod2b _ = SNil
     instance SC2 a => SingI (Method2aSym0 :: (~>) b a) where
-      sing = (singFun1 @Method2aSym0) sMethod2a
+      sing = singFun1 @Method2aSym0 sMethod2a
     instance SC2 a => SingI (Method2bSym0 :: (~>) b a) where
-      sing = (singFun1 @Method2bSym0) sMethod2b
+      sing = singFun1 @Method2bSym0 sMethod2b
diff --git a/tests/compile-and-dump/Singletons/T367.golden b/tests/compile-and-dump/Singletons/T367.golden
--- a/tests/compile-and-dump/Singletons/T367.golden
+++ b/tests/compile-and-dump/Singletons/T367.golden
@@ -8,33 +8,33 @@
       where
         Const'Sym0KindInference :: SameKind (Apply Const'Sym0 arg) (Const'Sym1 arg) =>
                                    Const'Sym0 a0123456789876543210
-    type instance Apply Const'Sym0 a0123456789876543210 = Const'Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b a) Const'Sym0 a0123456789876543210 = Const'Sym1 a0123456789876543210
     instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings Const'Sym0 where
       Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
-        = snd (((,) Const'Sym0KindInference) ())
+        = snd ((,) Const'Sym0KindInference ())
     type Const'Sym1 :: a -> (~>) b a
     data Const'Sym1 (a0123456789876543210 :: a) :: (~>) b a
       where
         Const'Sym1KindInference :: SameKind (Apply (Const'Sym1 a0123456789876543210) arg) (Const'Sym2 a0123456789876543210 arg) =>
                                    Const'Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Const'Sym1 a0123456789876543210) a0123456789876543210 = Const' a0123456789876543210 a0123456789876543210
+    type instance Apply @b @a (Const'Sym1 a0123456789876543210) a0123456789876543210 = Const' a0123456789876543210 a0123456789876543210
     instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings (Const'Sym1 a0123456789876543210) where
       Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
-        = snd (((,) Const'Sym1KindInference) ())
+        = snd ((,) Const'Sym1KindInference ())
     type Const'Sym2 :: a -> b -> a
-    type family Const'Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
+    type family Const'Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
       Const'Sym2 a0123456789876543210 a0123456789876543210 = Const' a0123456789876543210 a0123456789876543210
     type Const' :: a -> b -> a
-    type family Const' (a :: a) (a :: b) :: a where
+    type family Const' @a @b (a :: a) (a :: b) :: a where
       Const' x _ = x
     sConst' ::
-      forall a b (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply Const'Sym0 t) t :: a)
+      (forall (t :: a) (t :: b).
+       Sing t -> Sing t -> Sing (Const' t t :: a) :: Type)
     sConst' (sX :: Sing x) _ = sX
     instance SingI (Const'Sym0 :: (~>) a ((~>) b a)) where
-      sing = (singFun2 @Const'Sym0) sConst'
+      sing = singFun2 @Const'Sym0 sConst'
     instance SingI d => SingI (Const'Sym1 (d :: a) :: (~>) b a) where
-      sing = (singFun1 @(Const'Sym1 (d :: a))) (sConst' (sing @d))
+      sing = singFun1 @(Const'Sym1 (d :: a)) (sConst' (sing @d))
     instance SingI1 (Const'Sym1 :: a -> (~>) b a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(Const'Sym1 (d :: a))) (sConst' s)
+        = singFun1 @(Const'Sym1 (d :: a)) (sConst' s)
diff --git a/tests/compile-and-dump/Singletons/T371.golden b/tests/compile-and-dump/Singletons/T371.golden
--- a/tests/compile-and-dump/Singletons/T371.golden
+++ b/tests/compile-and-dump/Singletons/T371.golden
@@ -13,119 +13,56 @@
     data Y (a :: Type)
       = Y1 | Y2 (X a)
       deriving Show
-    type X1Sym0 :: forall (a :: Type). X (a :: Type)
-    type family X1Sym0 :: X (a :: Type) where
+    type X1Sym0 :: forall (a :: Type). X a
+    type family X1Sym0 @(a :: Type) :: X a where
       X1Sym0 = X1
-    type X2Sym0 :: forall (a :: Type). (~>) (Y a) (X (a :: Type))
-    data X2Sym0 :: (~>) (Y a) (X (a :: Type))
+    type X2Sym0 :: forall (a :: Type). (~>) (Y a) (X a)
+    data X2Sym0 :: (~>) (Y a) (X a)
       where
         X2Sym0KindInference :: SameKind (Apply X2Sym0 arg) (X2Sym1 arg) =>
                                X2Sym0 a0123456789876543210
-    type instance Apply X2Sym0 a0123456789876543210 = X2 a0123456789876543210
+    type instance Apply @(Y a) @(X a) X2Sym0 a0123456789876543210 = X2 a0123456789876543210
     instance SuppressUnusedWarnings X2Sym0 where
-      suppressUnusedWarnings = snd (((,) X2Sym0KindInference) ())
-    type X2Sym1 :: forall (a :: Type). Y a -> X (a :: Type)
-    type family X2Sym1 (a0123456789876543210 :: Y a) :: X (a :: Type) where
+      suppressUnusedWarnings = snd ((,) X2Sym0KindInference ())
+    type X2Sym1 :: forall (a :: Type). Y a -> X a
+    type family X2Sym1 @(a :: Type) (a0123456789876543210 :: Y a) :: X a where
       X2Sym1 a0123456789876543210 = X2 a0123456789876543210
-    type Y1Sym0 :: forall (a :: Type). Y (a :: Type)
-    type family Y1Sym0 :: Y (a :: Type) where
+    type Y1Sym0 :: forall (a :: Type). Y a
+    type family Y1Sym0 @(a :: Type) :: Y a where
       Y1Sym0 = Y1
-    type Y2Sym0 :: forall (a :: Type). (~>) (X a) (Y (a :: Type))
-    data Y2Sym0 :: (~>) (X a) (Y (a :: Type))
+    type Y2Sym0 :: forall (a :: Type). (~>) (X a) (Y a)
+    data Y2Sym0 :: (~>) (X a) (Y a)
       where
         Y2Sym0KindInference :: SameKind (Apply Y2Sym0 arg) (Y2Sym1 arg) =>
                                Y2Sym0 a0123456789876543210
-    type instance Apply Y2Sym0 a0123456789876543210 = Y2 a0123456789876543210
+    type instance Apply @(X a) @(Y a) Y2Sym0 a0123456789876543210 = Y2 a0123456789876543210
     instance SuppressUnusedWarnings Y2Sym0 where
-      suppressUnusedWarnings = snd (((,) Y2Sym0KindInference) ())
-    type Y2Sym1 :: forall (a :: Type). X a -> Y (a :: Type)
-    type family Y2Sym1 (a0123456789876543210 :: X a) :: Y (a :: Type) where
+      suppressUnusedWarnings = snd ((,) Y2Sym0KindInference ())
+    type Y2Sym1 :: forall (a :: Type). X a -> Y a
+    type family Y2Sym1 @(a :: Type) (a0123456789876543210 :: X a) :: Y a where
       Y2Sym1 a0123456789876543210 = Y2 a0123456789876543210
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> X a -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: X a) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where
-      ShowsPrec_0123456789876543210 _ X1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "X1") a_0123456789876543210
-      ShowsPrec_0123456789876543210 p_0123456789876543210 (X2 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "X2 ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> X a -> (~>) GHC.Types.Symbol GHC.Types.Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: X a) :: (~>) GHC.Types.Symbol GHC.Types.Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> X a -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: X a) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+    type ShowsPrec_0123456789876543210 :: forall a. GHC.Internal.Bignum.Natural.Natural
+                                                    -> X a
+                                                       -> GHC.Internal.Types.Symbol
+                                                          -> GHC.Internal.Types.Symbol
+    type family ShowsPrec_0123456789876543210 @a (a :: GHC.Internal.Bignum.Natural.Natural) (a :: X a) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where
+      ShowsPrec_0123456789876543210 @a (_ :: GHC.Internal.Bignum.Natural.Natural) (X1 :: X a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply ShowStringSym0 "X1") a_0123456789876543210
+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (X2 arg_0123456789876543210 :: X a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "X2 ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210
     instance PShow (X a) where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
-    type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural
-                                          -> Y a -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Y a) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where
-      ShowsPrec_0123456789876543210 _ Y1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "Y1") a_0123456789876543210
-      ShowsPrec_0123456789876543210 p_0123456789876543210 (Y2 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Y2 ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210
-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-      where
-        ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210
-    instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())
-    type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural
-                                              -> (~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)
-      where
-        ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())
-    type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural
-                                              -> Y a -> (~>) GHC.Types.Symbol GHC.Types.Symbol
-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Y a) :: (~>) GHC.Types.Symbol GHC.Types.Symbol
-      where
-        ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
-                                                          ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
-      suppressUnusedWarnings
-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())
-    type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural
-                                              -> Y a -> GHC.Types.Symbol -> GHC.Types.Symbol
-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Y a) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where
-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
+    type ShowsPrec_0123456789876543210 :: forall a. GHC.Internal.Bignum.Natural.Natural
+                                                    -> Y a
+                                                       -> GHC.Internal.Types.Symbol
+                                                          -> GHC.Internal.Types.Symbol
+    type family ShowsPrec_0123456789876543210 @a (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Y a) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where
+      ShowsPrec_0123456789876543210 @a (_ :: GHC.Internal.Bignum.Natural.Natural) (Y1 :: Y a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply ShowStringSym0 "Y1") a_0123456789876543210
+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (Y2 arg_0123456789876543210 :: Y a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Y2 ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210
     instance PShow (Y a) where
-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
     data SX :: forall (a :: Type). X a -> Type
       where
-        SX1 :: forall (a :: Type). SX (X1 :: X (a :: Type))
-        SX2 :: forall (a :: Type) (n :: Y a).
-               (Sing n) -> SX (X2 n :: X (a :: Type))
+        SX1 :: forall (a :: Type). SX (X1 :: X a)
+        SX2 :: forall (a :: Type) (n :: Y a). (Sing n) -> SX (X2 n :: X a)
     type instance Sing @(X a) = SX
     instance SingKind a => SingKind (X a) where
       type Demote (X a) = X (Demote a)
@@ -133,12 +70,12 @@
       fromSing (SX2 b) = X2 (fromSing b)
       toSing X1 = SomeSing SX1
       toSing (X2 (b :: Demote (Y a)))
-        = case toSing b :: SomeSing (Y a) of SomeSing c -> SomeSing (SX2 c)
+        = (\cases (SomeSing c) -> SomeSing (SX2 c))
+            (toSing b :: SomeSing (Y a))
     data SY :: forall (a :: Type). Y a -> Type
       where
-        SY1 :: forall (a :: Type). SY (Y1 :: Y (a :: Type))
-        SY2 :: forall (a :: Type) (n :: X a).
-               (Sing n) -> SY (Y2 n :: Y (a :: Type))
+        SY1 :: forall (a :: Type). SY (Y1 :: Y a)
+        SY2 :: forall (a :: Type) (n :: X a). (Sing n) -> SY (Y2 n :: Y a)
     type instance Sing @(Y a) = SY
     instance SingKind a => SingKind (Y a) where
       type Demote (Y a) = Y (Demote a)
@@ -146,78 +83,69 @@
       fromSing (SY2 b) = Y2 (fromSing b)
       toSing Y1 = SomeSing SY1
       toSing (Y2 (b :: Demote (X a)))
-        = case toSing b :: SomeSing (X a) of SomeSing c -> SomeSing (SY2 c)
+        = (\cases (SomeSing c) -> SomeSing (SY2 c))
+            (toSing b :: SomeSing (X a))
     instance SShow (Y a) => SShow (X a) where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: X a)
-               (t3 :: GHC.Types.Symbol). Sing t1
-                                         -> Sing t2
-                                            -> Sing t3
-                                               -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-                                                                                              -> Type) t1) t2) t3)
       sShowsPrec
         _
         SX1
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "X1")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "X1"))
             sA_0123456789876543210
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         (SX2 (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "X2 "))))
-                   ((applySing
-                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                          (sFromInteger (sing :: Sing 11))))
-                      sArg_0123456789876543210))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "X2 ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @ShowsPrecSym0 sShowsPrec)
+                        (sFromInteger (sing :: Sing 11)))
+                     sArg_0123456789876543210)))
             sA_0123456789876543210
     instance SShow (X a) => SShow (Y a) where
-      sShowsPrec ::
-        forall (t1 :: GHC.Num.Natural.Natural)
-               (t2 :: Y a)
-               (t3 :: GHC.Types.Symbol). Sing t1
-                                         -> Sing t2
-                                            -> Sing t3
-                                               -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))
-                                                                                              -> Type) t1) t2) t3)
       sShowsPrec
         _
         SY1
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                (sing :: Sing "Y1")))
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Y1"))
             sA_0123456789876543210
       sShowsPrec
         (sP_0123456789876543210 :: Sing p_0123456789876543210)
         (SY2 (sArg_0123456789876543210 :: Sing arg_0123456789876543210))
         (sA_0123456789876543210 :: Sing a_0123456789876543210)
-        = (applySing
-             ((applySing
-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))
-                    ((applySing
-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))
-                       (sFromInteger (sing :: Sing 10)))))
-                ((applySing
-                    ((applySing ((singFun3 @(.@#@$)) (%.)))
-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))
-                          (sing :: Sing "Y2 "))))
-                   ((applySing
-                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))
-                          (sFromInteger (sing :: Sing 11))))
-                      sArg_0123456789876543210))))
+        = applySing
+            (applySing
+               (applySing
+                  (singFun3 @ShowParenSym0 sShowParen)
+                  (applySing
+                     (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210)
+                     (sFromInteger (sing :: Sing 10))))
+               (applySing
+                  (applySing
+                     (singFun3 @(.@#@$) (%.))
+                     (applySing
+                        (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Y2 ")))
+                  (applySing
+                     (applySing
+                        (singFun3 @ShowsPrecSym0 sShowsPrec)
+                        (sFromInteger (sing :: Sing 11)))
+                     sArg_0123456789876543210)))
             sA_0123456789876543210
     deriving instance Data.Singletons.ShowSing.ShowSing (Y a) =>
                       Show (SX (z :: X a))
@@ -229,13 +157,13 @@
       sing = SX2 sing
     instance SingI1 X2 where
       liftSing = SX2
-    instance SingI (X2Sym0 :: (~>) (Y a) (X (a :: Type))) where
-      sing = (singFun1 @X2Sym0) SX2
+    instance SingI (X2Sym0 :: (~>) (Y a) (X a)) where
+      sing = singFun1 @X2Sym0 SX2
     instance SingI Y1 where
       sing = SY1
     instance SingI n => SingI (Y2 (n :: X a)) where
       sing = SY2 sing
     instance SingI1 Y2 where
       liftSing = SY2
-    instance SingI (Y2Sym0 :: (~>) (X a) (Y (a :: Type))) where
-      sing = (singFun1 @Y2Sym0) SY2
+    instance SingI (Y2Sym0 :: (~>) (X a) (Y a)) where
+      sing = singFun1 @Y2Sym0 SY2
diff --git a/tests/compile-and-dump/Singletons/T376.golden b/tests/compile-and-dump/Singletons/T376.golden
--- a/tests/compile-and-dump/Singletons/T376.golden
+++ b/tests/compile-and-dump/Singletons/T376.golden
@@ -10,17 +10,17 @@
       where
         FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
                               FSym0 a0123456789876543210
-    type instance Apply FSym0 a0123456789876543210 = FSym1 a0123456789876543210
+    type instance Apply @((~>) () ()) @((~>) () ()) FSym0 a0123456789876543210 = FSym1 a0123456789876543210
     instance SuppressUnusedWarnings FSym0 where
-      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FSym0KindInference ())
     type FSym1 :: (~>) () () -> (~>) () ()
     data FSym1 (a0123456789876543210 :: (~>) () ()) :: (~>) () ()
       where
         FSym1KindInference :: SameKind (Apply (FSym1 a0123456789876543210) arg) (FSym2 a0123456789876543210 arg) =>
                               FSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FSym1 a0123456789876543210) a0123456789876543210 = F a0123456789876543210 a0123456789876543210
+    type instance Apply @() @() (FSym1 a0123456789876543210) a0123456789876543210 = F a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (FSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) FSym1KindInference ())
     type FSym2 :: (~>) () () -> () -> ()
     type family FSym2 (a0123456789876543210 :: (~>) () ()) (a0123456789876543210 :: ()) :: () where
       FSym2 a0123456789876543210 a0123456789876543210 = F a0123456789876543210 a0123456789876543210
@@ -28,17 +28,17 @@
     type family F (a :: (~>) () ()) (a :: ()) :: () where
       F g a_0123456789876543210 = Apply (g :: (~>) () ()) a_0123456789876543210
     sF ::
-      forall (t :: (~>) () ()) (t :: ()). Sing t
-                                          -> Sing t -> Sing (Apply (Apply FSym0 t) t :: ())
+      (forall (t :: (~>) () ()) (t :: ()).
+       Sing t -> Sing t -> Sing (F t t :: ()) :: Type)
     sF
       (sG :: Sing g)
       (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing (sG :: Sing (g :: (~>) () ()))) sA_0123456789876543210
+      = applySing (sG :: Sing (g :: (~>) () ())) sA_0123456789876543210
     instance SingI (FSym0 :: (~>) ((~>) () ()) ((~>) () ())) where
-      sing = (singFun2 @FSym0) sF
+      sing = singFun2 @FSym0 sF
     instance SingI d =>
              SingI (FSym1 (d :: (~>) () ()) :: (~>) () ()) where
-      sing = (singFun1 @(FSym1 (d :: (~>) () ()))) (sF (sing @d))
+      sing = singFun1 @(FSym1 (d :: (~>) () ())) (sF (sing @d))
     instance SingI1 (FSym1 :: (~>) () () -> (~>) () ()) where
       liftSing (s :: Sing (d :: (~>) () ()))
-        = (singFun1 @(FSym1 (d :: (~>) () ()))) (sF s)
+        = singFun1 @(FSym1 (d :: (~>) () ())) (sF s)
diff --git a/tests/compile-and-dump/Singletons/T378a.golden b/tests/compile-and-dump/Singletons/T378a.golden
--- a/tests/compile-and-dump/Singletons/T378a.golden
+++ b/tests/compile-and-dump/Singletons/T378a.golden
@@ -19,50 +19,50 @@
         Proxy3 :: forall a. Proxy a
         Proxy4 :: forall k (a :: k). Proxy a
     type Proxy1Sym0 :: Proxy a
-    type family Proxy1Sym0 :: Proxy a where
+    type family Proxy1Sym0 @a :: Proxy a where
       Proxy1Sym0 = Proxy1
     type Proxy2Sym0 :: Proxy (a :: k)
-    type family Proxy2Sym0 :: Proxy (a :: k) where
+    type family Proxy2Sym0 @k @(a :: k) :: Proxy (a :: k) where
       Proxy2Sym0 = Proxy2
     type Proxy3Sym0 :: forall a. Proxy a
-    type family Proxy3Sym0 :: Proxy a where
+    type family Proxy3Sym0 @a :: Proxy a where
       Proxy3Sym0 = Proxy3
     type Proxy4Sym0 :: forall k (a :: k). Proxy a
-    type family Proxy4Sym0 :: Proxy a where
+    type family Proxy4Sym0 @k @(a :: k) :: Proxy a where
       Proxy4Sym0 = Proxy4
     type ConstBASym0 :: forall b a. (~>) a ((~>) b a)
     data ConstBASym0 :: (~>) a ((~>) b a)
       where
         ConstBASym0KindInference :: SameKind (Apply ConstBASym0 arg) (ConstBASym1 arg) =>
                                     ConstBASym0 a0123456789876543210
-    type instance Apply ConstBASym0 a0123456789876543210 = ConstBASym1 a0123456789876543210
+    type instance Apply @a @((~>) b a) ConstBASym0 a0123456789876543210 = ConstBASym1 a0123456789876543210
     instance SuppressUnusedWarnings ConstBASym0 where
-      suppressUnusedWarnings = snd (((,) ConstBASym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) ConstBASym0KindInference ())
     type ConstBASym1 :: forall b a. a -> (~>) b a
     data ConstBASym1 (a0123456789876543210 :: a) :: (~>) b a
       where
         ConstBASym1KindInference :: SameKind (Apply (ConstBASym1 a0123456789876543210) arg) (ConstBASym2 a0123456789876543210 arg) =>
                                     ConstBASym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ConstBASym1 a0123456789876543210) a0123456789876543210 = ConstBA a0123456789876543210 a0123456789876543210
+    type instance Apply @b @a (ConstBASym1 a0123456789876543210) a0123456789876543210 = ConstBA a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (ConstBASym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) ConstBASym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) ConstBASym1KindInference ())
     type ConstBASym2 :: forall b a. a -> b -> a
-    type family ConstBASym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
+    type family ConstBASym2 @b @a (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
       ConstBASym2 a0123456789876543210 a0123456789876543210 = ConstBA a0123456789876543210 a0123456789876543210
     type ConstBA :: forall b a. a -> b -> a
-    type family ConstBA (a :: a) (a :: b) :: a where
-      ConstBA x _ = x
+    type family ConstBA @b @a (a :: a) (a :: b) :: a where
+      ConstBA @b @a (x :: a) (_ :: b) = x
     sConstBA ::
       forall b a (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply ConstBASym0 t) t :: a)
+                                    -> Sing t -> Sing (ConstBA t t :: a)
     sConstBA (sX :: Sing x) _ = sX
     instance SingI (ConstBASym0 :: (~>) a ((~>) b a)) where
-      sing = (singFun2 @ConstBASym0) sConstBA
+      sing = singFun2 @ConstBASym0 sConstBA
     instance SingI d => SingI (ConstBASym1 (d :: a) :: (~>) b a) where
-      sing = (singFun1 @(ConstBASym1 (d :: a))) (sConstBA (sing @d))
+      sing = singFun1 @(ConstBASym1 (d :: a)) (sConstBA (sing @d))
     instance SingI1 (ConstBASym1 :: a -> (~>) b a) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(ConstBASym1 (d :: a))) (sConstBA s)
+        = singFun1 @(ConstBASym1 (d :: a)) (sConstBA s)
     data SProxy :: forall k (a :: k). Proxy a -> Type
       where
         SProxy1 :: forall a. SProxy (Proxy1 :: Proxy a)
diff --git a/tests/compile-and-dump/Singletons/T378b.golden b/tests/compile-and-dump/Singletons/T378b.golden
--- a/tests/compile-and-dump/Singletons/T378b.golden
+++ b/tests/compile-and-dump/Singletons/T378b.golden
@@ -21,36 +21,28 @@
     f _ _ = ()
     natMinus :: Nat -> Nat -> Nat
     natMinus Zero _ = Zero
-    natMinus (Succ a) (Succ b) = (natMinus a) b
+    natMinus (Succ a) (Succ b) = natMinus a b
     natMinus a@(Succ _) Zero = a
-    data Let0123456789876543210ASym0 wild_01234567898765432100123456789876543210
-      where
-        Let0123456789876543210ASym0KindInference :: SameKind (Apply Let0123456789876543210ASym0 arg) (Let0123456789876543210ASym1 arg) =>
-                                                    Let0123456789876543210ASym0 wild_01234567898765432100123456789876543210
-    type instance Apply Let0123456789876543210ASym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210A wild_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210ASym0 where
-      suppressUnusedWarnings
-        = snd (((,) Let0123456789876543210ASym0KindInference) ())
-    type family Let0123456789876543210ASym1 wild_01234567898765432100123456789876543210 where
-      Let0123456789876543210ASym1 wild_01234567898765432100123456789876543210 = Let0123456789876543210A wild_01234567898765432100123456789876543210
-    type family Let0123456789876543210A wild_0123456789876543210 where
+    type family Let0123456789876543210ASym0 wild_01234567898765432100123456789876543210 where
+      Let0123456789876543210ASym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210A wild_01234567898765432100123456789876543210
+    type family Let0123456789876543210A wild_01234567898765432100123456789876543210 where
       Let0123456789876543210A wild_0123456789876543210 = Apply SuccSym0 wild_0123456789876543210
     type NatMinusSym0 :: (~>) Nat ((~>) Nat Nat)
     data NatMinusSym0 :: (~>) Nat ((~>) Nat Nat)
       where
         NatMinusSym0KindInference :: SameKind (Apply NatMinusSym0 arg) (NatMinusSym1 arg) =>
                                      NatMinusSym0 a0123456789876543210
-    type instance Apply NatMinusSym0 a0123456789876543210 = NatMinusSym1 a0123456789876543210
+    type instance Apply @Nat @((~>) Nat Nat) NatMinusSym0 a0123456789876543210 = NatMinusSym1 a0123456789876543210
     instance SuppressUnusedWarnings NatMinusSym0 where
-      suppressUnusedWarnings = snd (((,) NatMinusSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) NatMinusSym0KindInference ())
     type NatMinusSym1 :: Nat -> (~>) Nat Nat
     data NatMinusSym1 (a0123456789876543210 :: Nat) :: (~>) Nat Nat
       where
         NatMinusSym1KindInference :: SameKind (Apply (NatMinusSym1 a0123456789876543210) arg) (NatMinusSym2 a0123456789876543210 arg) =>
                                      NatMinusSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (NatMinusSym1 a0123456789876543210) a0123456789876543210 = NatMinus a0123456789876543210 a0123456789876543210
+    type instance Apply @Nat @Nat (NatMinusSym1 a0123456789876543210) a0123456789876543210 = NatMinus a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (NatMinusSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) NatMinusSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) NatMinusSym1KindInference ())
     type NatMinusSym2 :: Nat -> Nat -> Nat
     type family NatMinusSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where
       NatMinusSym2 a0123456789876543210 a0123456789876543210 = NatMinus a0123456789876543210 a0123456789876543210
@@ -59,71 +51,67 @@
       where
         FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
                               FSym0 a0123456789876543210
-    type instance Apply FSym0 a0123456789876543210 = FSym1 a0123456789876543210
+    type instance Apply @a @((~>) b ()) FSym0 a0123456789876543210 = FSym1 a0123456789876543210
     instance SuppressUnusedWarnings FSym0 where
-      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FSym0KindInference ())
     type FSym1 :: forall b a. a -> (~>) b ()
     data FSym1 (a0123456789876543210 :: a) :: (~>) b ()
       where
         FSym1KindInference :: SameKind (Apply (FSym1 a0123456789876543210) arg) (FSym2 a0123456789876543210 arg) =>
                               FSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (FSym1 a0123456789876543210) a0123456789876543210 = F a0123456789876543210 a0123456789876543210
+    type instance Apply @b @() (FSym1 a0123456789876543210) a0123456789876543210 = F a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (FSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) FSym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) FSym1KindInference ())
     type FSym2 :: forall b a. a -> b -> ()
-    type family FSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: () where
+    type family FSym2 @b @a (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: () where
       FSym2 a0123456789876543210 a0123456789876543210 = F a0123456789876543210 a0123456789876543210
     type NatMinus :: Nat -> Nat -> Nat
     type family NatMinus (a :: Nat) (a :: Nat) :: Nat where
       NatMinus 'Zero _ = ZeroSym0
       NatMinus ('Succ a) ('Succ b) = Apply (Apply NatMinusSym0 a) b
-      NatMinus ('Succ wild_0123456789876543210) 'Zero = Let0123456789876543210ASym1 wild_0123456789876543210
+      NatMinus ('Succ wild_0123456789876543210) 'Zero = Let0123456789876543210ASym0 wild_0123456789876543210
     type F :: forall b a. a -> b -> ()
-    type family F (a :: a) (a :: b) :: () where
-      F _ _ = Tuple0Sym0
+    type family F @b @a (a :: a) (a :: b) :: () where
+      F @b @a (_ :: a) (_ :: b) = Tuple0Sym0
     type PC :: forall b a. a -> b -> Constraint
     class PC x y
     sNatMinus ::
-      forall (t :: Nat) (t :: Nat). Sing t
-                                    -> Sing t -> Sing (Apply (Apply NatMinusSym0 t) t :: Nat)
+      (forall (t :: Nat) (t :: Nat).
+       Sing t -> Sing t -> Sing (NatMinus t t :: Nat) :: Type)
     sF ::
       forall b a (t :: a) (t :: b). Sing t
-                                    -> Sing t -> Sing (Apply (Apply FSym0 t) t :: ())
+                                    -> Sing t -> Sing (F t t :: ())
     sNatMinus SZero _ = SZero
     sNatMinus (SSucc (sA :: Sing a)) (SSucc (sB :: Sing b))
-      = (applySing ((applySing ((singFun2 @NatMinusSym0) sNatMinus)) sA))
-          sB
+      = applySing (applySing (singFun2 @NatMinusSym0 sNatMinus) sA) sB
     sNatMinus
       (SSucc (sWild_0123456789876543210 :: Sing wild_0123456789876543210))
       SZero
       = let
-          sA ::
-            Sing @_ (Let0123456789876543210ASym1 wild_0123456789876543210)
-          sA
-            = (applySing ((singFun1 @SuccSym0) SSucc))
-                sWild_0123456789876543210
+          sA :: Sing @_ (Let0123456789876543210A wild_0123456789876543210)
+          sA = applySing (singFun1 @SuccSym0 SSucc) sWild_0123456789876543210
         in sA
     sF _ _ = STuple0
     instance SingI (NatMinusSym0 :: (~>) Nat ((~>) Nat Nat)) where
-      sing = (singFun2 @NatMinusSym0) sNatMinus
+      sing = singFun2 @NatMinusSym0 sNatMinus
     instance SingI d =>
              SingI (NatMinusSym1 (d :: Nat) :: (~>) Nat Nat) where
-      sing = (singFun1 @(NatMinusSym1 (d :: Nat))) (sNatMinus (sing @d))
+      sing = singFun1 @(NatMinusSym1 (d :: Nat)) (sNatMinus (sing @d))
     instance SingI1 (NatMinusSym1 :: Nat -> (~>) Nat Nat) where
       liftSing (s :: Sing (d :: Nat))
-        = (singFun1 @(NatMinusSym1 (d :: Nat))) (sNatMinus s)
+        = singFun1 @(NatMinusSym1 (d :: Nat)) (sNatMinus s)
     instance SingI (FSym0 :: (~>) a ((~>) b ())) where
-      sing = (singFun2 @FSym0) sF
+      sing = singFun2 @FSym0 sF
     instance SingI d => SingI (FSym1 (d :: a) :: (~>) b ()) where
-      sing = (singFun1 @(FSym1 (d :: a))) (sF (sing @d))
+      sing = singFun1 @(FSym1 (d :: a)) (sF (sing @d))
     instance SingI1 (FSym1 :: a -> (~>) b ()) where
-      liftSing (s :: Sing (d :: a)) = (singFun1 @(FSym1 (d :: a))) (sF s)
+      liftSing (s :: Sing (d :: a)) = singFun1 @(FSym1 (d :: a)) (sF s)
     type SD :: forall b a (x :: a) (y :: b). D x y -> Type
     data SD :: forall b a (x :: a) (y :: b). D x y -> Type
     type instance Sing @(D x y) = SD
     instance (SingKind x, SingKind y) => SingKind (D x y) where
       type Demote (D x y) = D (Demote x) (Demote y)
-      fromSing x = case x of {}
-      toSing x = SomeSing (case x of {})
+      fromSing x = (\case) x
+      toSing x = SomeSing ((\case) x)
     class SC x y
     type SC :: forall b a. a -> b -> Constraint
diff --git a/tests/compile-and-dump/Singletons/T401.golden b/tests/compile-and-dump/Singletons/T401.golden
--- a/tests/compile-and-dump/Singletons/T401.golden
+++ b/tests/compile-and-dump/Singletons/T401.golden
@@ -1,10 +1,10 @@
 
-Singletons/T401.hs:0:0: error: Q monad failure
+Singletons/T401.hs:0:0: error: [GHC-39584] Q monad failure
   |
 5 | $(singletons [d|
   |  ^^^^^^^^^^^^^^^...
 
-Singletons/T401.hs:0:0: error:
+Singletons/T401.hs:0:0: error: [GHC-39584]
     `singletons-th` does not support higher-rank `forall`s
 In the type: (forall a_0 . a_0 -> a_0) -> b_1 -> b_1
 
diff --git a/tests/compile-and-dump/Singletons/T401b.golden b/tests/compile-and-dump/Singletons/T401b.golden
--- a/tests/compile-and-dump/Singletons/T401b.golden
+++ b/tests/compile-and-dump/Singletons/T401b.golden
@@ -1,10 +1,10 @@
 
-Singletons/T401b.hs:0:0: error: Q monad failure
+Singletons/T401b.hs:0:0: error: [GHC-39584] Q monad failure
   |
 5 | $(singletons [d|
   |  ^^^^^^^^^^^^^^^...
 
-Singletons/T401b.hs:0:0: error:
+Singletons/T401b.hs:0:0: error: [GHC-39584]
     `singletons-th` does not support higher-rank `forall`s
 In the type: (forall a_0 . a_0) -> T_1
 
diff --git a/tests/compile-and-dump/Singletons/T402.golden b/tests/compile-and-dump/Singletons/T402.golden
--- a/tests/compile-and-dump/Singletons/T402.golden
+++ b/tests/compile-and-dump/Singletons/T402.golden
@@ -6,8 +6,8 @@
       where
         AnyOfKindSym0KindInference :: SameKind (Apply AnyOfKindSym0 arg) (AnyOfKindSym1 arg) =>
                                       AnyOfKindSym0 k0123456789876543210
-    type instance Apply AnyOfKindSym0 k0123456789876543210 = AnyOfKind k0123456789876543210
+    type instance Apply @Type @k0123456789876543210 AnyOfKindSym0 k0123456789876543210 = AnyOfKind k0123456789876543210
     instance SuppressUnusedWarnings AnyOfKindSym0 where
-      suppressUnusedWarnings = snd (((,) AnyOfKindSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) AnyOfKindSym0KindInference ())
     type family AnyOfKindSym1 (k0123456789876543210 :: Type) :: k0123456789876543210 where
       AnyOfKindSym1 k0123456789876543210 = AnyOfKind k0123456789876543210
diff --git a/tests/compile-and-dump/Singletons/T410.golden b/tests/compile-and-dump/Singletons/T410.golden
--- a/tests/compile-and-dump/Singletons/T410.golden
+++ b/tests/compile-and-dump/Singletons/T410.golden
@@ -15,47 +15,26 @@
       where
         EqualsSym0KindInference :: SameKind (Apply EqualsSym0 arg) (EqualsSym1 arg) =>
                                    EqualsSym0 a0123456789876543210
-    type instance Apply EqualsSym0 a0123456789876543210 = EqualsSym1 a0123456789876543210
+    type instance Apply @a @((~>) a Bool) EqualsSym0 a0123456789876543210 = EqualsSym1 a0123456789876543210
     instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings EqualsSym0 where
       Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
-        = snd (((,) EqualsSym0KindInference) ())
+        = snd ((,) EqualsSym0KindInference ())
     type EqualsSym1 :: forall a. a -> (~>) a Bool
     data EqualsSym1 (a0123456789876543210 :: a) :: (~>) a Bool
       where
         EqualsSym1KindInference :: SameKind (Apply (EqualsSym1 a0123456789876543210) arg) (EqualsSym2 a0123456789876543210 arg) =>
                                    EqualsSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (EqualsSym1 a0123456789876543210) a0123456789876543210 = Equals a0123456789876543210 a0123456789876543210
+    type instance Apply @a @Bool (EqualsSym1 a0123456789876543210) a0123456789876543210 = Equals a0123456789876543210 a0123456789876543210
     instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings (EqualsSym1 a0123456789876543210) where
       Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
-        = snd (((,) EqualsSym1KindInference) ())
+        = snd ((,) EqualsSym1KindInference ())
     type EqualsSym2 :: forall a. a -> a -> Bool
-    type family EqualsSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Bool where
+    type family EqualsSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Bool where
       EqualsSym2 a0123456789876543210 a0123456789876543210 = Equals a0123456789876543210 a0123456789876543210
     class PEq a where
       type family Equals (arg :: a) (arg :: a) :: Bool
     type Equals_0123456789876543210 :: () -> () -> Bool
     type family Equals_0123456789876543210 (a :: ()) (a :: ()) :: Bool where
       Equals_0123456789876543210 '() '() = TrueSym0
-    type Equals_0123456789876543210Sym0 :: (~>) () ((~>) () Bool)
-    data Equals_0123456789876543210Sym0 :: (~>) () ((~>) () Bool)
-      where
-        Equals_0123456789876543210Sym0KindInference :: SameKind (Apply Equals_0123456789876543210Sym0 arg) (Equals_0123456789876543210Sym1 arg) =>
-                                                       Equals_0123456789876543210Sym0 a0123456789876543210
-    type instance Apply Equals_0123456789876543210Sym0 a0123456789876543210 = Equals_0123456789876543210Sym1 a0123456789876543210
-    instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings Equals_0123456789876543210Sym0 where
-      Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
-        = snd (((,) Equals_0123456789876543210Sym0KindInference) ())
-    type Equals_0123456789876543210Sym1 :: () -> (~>) () Bool
-    data Equals_0123456789876543210Sym1 (a0123456789876543210 :: ()) :: (~>) () Bool
-      where
-        Equals_0123456789876543210Sym1KindInference :: SameKind (Apply (Equals_0123456789876543210Sym1 a0123456789876543210) arg) (Equals_0123456789876543210Sym2 a0123456789876543210 arg) =>
-                                                       Equals_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (Equals_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Equals_0123456789876543210 a0123456789876543210 a0123456789876543210
-    instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings (Equals_0123456789876543210Sym1 a0123456789876543210) where
-      Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
-        = snd (((,) Equals_0123456789876543210Sym1KindInference) ())
-    type Equals_0123456789876543210Sym2 :: () -> () -> Bool
-    type family Equals_0123456789876543210Sym2 (a0123456789876543210 :: ()) (a0123456789876543210 :: ()) :: Bool where
-      Equals_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Equals_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PEq () where
-      type Equals a a = Apply (Apply Equals_0123456789876543210Sym0 a) a
+      type Equals a a = Equals_0123456789876543210 a a
diff --git a/tests/compile-and-dump/Singletons/T412.golden b/tests/compile-and-dump/Singletons/T412.golden
--- a/tests/compile-and-dump/Singletons/T412.golden
+++ b/tests/compile-and-dump/Singletons/T412.golden
@@ -30,136 +30,134 @@
       where
         T1aSym0KindInference :: SameKind (Apply T1aSym0 arg) (T1aSym1 arg) =>
                                 T1aSym0 a0123456789876543210
-    type instance Apply T1aSym0 a0123456789876543210 = T1aSym1 a0123456789876543210
+    type instance Apply @_ @_ T1aSym0 a0123456789876543210 = T1aSym1 a0123456789876543210
     instance SuppressUnusedWarnings T1aSym0 where
-      suppressUnusedWarnings = snd (((,) T1aSym0KindInference) ())
-    infixl 5 `T1aSym0`
+      suppressUnusedWarnings = snd ((,) T1aSym0KindInference ())
+    infixl 5 type `T1aSym0`
     data T1aSym1 a0123456789876543210 b0123456789876543210
       where
         T1aSym1KindInference :: SameKind (Apply (T1aSym1 a0123456789876543210) arg) (T1aSym2 a0123456789876543210 arg) =>
                                 T1aSym1 a0123456789876543210 b0123456789876543210
-    type instance Apply (T1aSym1 a0123456789876543210) b0123456789876543210 = T1a a0123456789876543210 b0123456789876543210
+    type instance Apply @_ @_ (T1aSym1 a0123456789876543210) b0123456789876543210 = T1a a0123456789876543210 b0123456789876543210
     instance SuppressUnusedWarnings (T1aSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) T1aSym1KindInference) ())
-    infixl 5 `T1aSym1`
+      suppressUnusedWarnings = snd ((,) T1aSym1KindInference ())
+    infixl 5 type `T1aSym1`
     type family T1aSym2 a0123456789876543210 b0123456789876543210 where
       T1aSym2 a0123456789876543210 b0123456789876543210 = T1a a0123456789876543210 b0123456789876543210
-    infixl 5 `T1aSym2`
+    infixl 5 type `T1aSym2`
     data T1bSym0 a0123456789876543210
       where
         T1bSym0KindInference :: SameKind (Apply T1bSym0 arg) (T1bSym1 arg) =>
                                 T1bSym0 a0123456789876543210
-    type instance Apply T1bSym0 a0123456789876543210 = T1bSym1 a0123456789876543210
+    type instance Apply @_ @_ T1bSym0 a0123456789876543210 = T1bSym1 a0123456789876543210
     instance SuppressUnusedWarnings T1bSym0 where
-      suppressUnusedWarnings = snd (((,) T1bSym0KindInference) ())
-    infixl 5 `T1bSym0`
+      suppressUnusedWarnings = snd ((,) T1bSym0KindInference ())
+    infixl 5 type `T1bSym0`
     data T1bSym1 a0123456789876543210 b0123456789876543210
       where
         T1bSym1KindInference :: SameKind (Apply (T1bSym1 a0123456789876543210) arg) (T1bSym2 a0123456789876543210 arg) =>
                                 T1bSym1 a0123456789876543210 b0123456789876543210
-    type instance Apply (T1bSym1 a0123456789876543210) b0123456789876543210 = T1b a0123456789876543210 b0123456789876543210
+    type instance Apply @_ @_ (T1bSym1 a0123456789876543210) b0123456789876543210 = T1b a0123456789876543210 b0123456789876543210
     instance SuppressUnusedWarnings (T1bSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) T1bSym1KindInference) ())
-    infixl 5 `T1bSym1`
+      suppressUnusedWarnings = snd ((,) T1bSym1KindInference ())
+    infixl 5 type `T1bSym1`
     type family T1bSym2 a0123456789876543210 b0123456789876543210 where
       T1bSym2 a0123456789876543210 b0123456789876543210 = T1b a0123456789876543210 b0123456789876543210
-    infixl 5 `T1bSym2`
+    infixl 5 type `T1bSym2`
     type MkD1Sym0 :: forall a b. (~>) a ((~>) b (D1 a b))
     data MkD1Sym0 :: (~>) a ((~>) b (D1 a b))
       where
         MkD1Sym0KindInference :: SameKind (Apply MkD1Sym0 arg) (MkD1Sym1 arg) =>
                                  MkD1Sym0 a0123456789876543210
-    type instance Apply MkD1Sym0 a0123456789876543210 = MkD1Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b (D1 a b)) MkD1Sym0 a0123456789876543210 = MkD1Sym1 a0123456789876543210
     instance SuppressUnusedWarnings MkD1Sym0 where
-      suppressUnusedWarnings = snd (((,) MkD1Sym0KindInference) ())
-    infixr 5 `MkD1Sym0`
+      suppressUnusedWarnings = snd ((,) MkD1Sym0KindInference ())
+    infixr 5 type `MkD1Sym0`
     type MkD1Sym1 :: forall a b. a -> (~>) b (D1 a b)
     data MkD1Sym1 (a0123456789876543210 :: a) :: (~>) b (D1 a b)
       where
         MkD1Sym1KindInference :: SameKind (Apply (MkD1Sym1 a0123456789876543210) arg) (MkD1Sym2 a0123456789876543210 arg) =>
                                  MkD1Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkD1Sym1 a0123456789876543210) a0123456789876543210 = MkD1 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @(D1 a b) (MkD1Sym1 a0123456789876543210) a0123456789876543210 = MkD1 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MkD1Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkD1Sym1KindInference) ())
-    infixr 5 `MkD1Sym1`
+      suppressUnusedWarnings = snd ((,) MkD1Sym1KindInference ())
+    infixr 5 type `MkD1Sym1`
     type MkD1Sym2 :: forall a b. a -> b -> D1 a b
-    type family MkD1Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: D1 a b where
+    type family MkD1Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: D1 a b where
       MkD1Sym2 a0123456789876543210 a0123456789876543210 = MkD1 a0123456789876543210 a0123456789876543210
-    infixr 5 `MkD1Sym2`
+    infixr 5 type `MkD1Sym2`
     type D1BSym0 :: forall a b. (~>) (D1 a b) b
     data D1BSym0 :: (~>) (D1 a b) b
       where
         D1BSym0KindInference :: SameKind (Apply D1BSym0 arg) (D1BSym1 arg) =>
                                 D1BSym0 a0123456789876543210
-    type instance Apply D1BSym0 a0123456789876543210 = D1B a0123456789876543210
+    type instance Apply @(D1 a b) @b D1BSym0 a0123456789876543210 = D1B a0123456789876543210
     instance SuppressUnusedWarnings D1BSym0 where
-      suppressUnusedWarnings = snd (((,) D1BSym0KindInference) ())
-    infixr 5 `D1BSym0`
+      suppressUnusedWarnings = snd ((,) D1BSym0KindInference ())
+    infixr 5 type `D1BSym0`
     type D1BSym1 :: forall a b. D1 a b -> b
-    type family D1BSym1 (a0123456789876543210 :: D1 a b) :: b where
+    type family D1BSym1 @a @b (a0123456789876543210 :: D1 a b) :: b where
       D1BSym1 a0123456789876543210 = D1B a0123456789876543210
-    infixr 5 `D1BSym1`
+    infixr 5 type `D1BSym1`
     type D1ASym0 :: forall a b. (~>) (D1 a b) a
     data D1ASym0 :: (~>) (D1 a b) a
       where
         D1ASym0KindInference :: SameKind (Apply D1ASym0 arg) (D1ASym1 arg) =>
                                 D1ASym0 a0123456789876543210
-    type instance Apply D1ASym0 a0123456789876543210 = D1A a0123456789876543210
+    type instance Apply @(D1 a b) @a D1ASym0 a0123456789876543210 = D1A a0123456789876543210
     instance SuppressUnusedWarnings D1ASym0 where
-      suppressUnusedWarnings = snd (((,) D1ASym0KindInference) ())
-    infixr 5 `D1ASym0`
+      suppressUnusedWarnings = snd ((,) D1ASym0KindInference ())
+    infixr 5 type `D1ASym0`
     type D1ASym1 :: forall a b. D1 a b -> a
-    type family D1ASym1 (a0123456789876543210 :: D1 a b) :: a where
+    type family D1ASym1 @a @b (a0123456789876543210 :: D1 a b) :: a where
       D1ASym1 a0123456789876543210 = D1A a0123456789876543210
-    infixr 5 `D1ASym1`
+    infixr 5 type `D1ASym1`
     type D1B :: forall a b. D1 a b -> b
-    type family D1B (a :: D1 a b) :: b where
-      D1B (MkD1 _ field) = field
+    type family D1B @a @b (a :: D1 a b) :: b where
+      D1B @a @b (MkD1 _ field :: D1 a b) = field
     type D1A :: forall a b. D1 a b -> a
-    type family D1A (a :: D1 a b) :: a where
-      D1A (MkD1 field _) = field
-    infixr 5 `D1B`
-    infixr 5 `D1A`
-    infix 5 `PC1`
+    type family D1A @a @b (a :: D1 a b) :: a where
+      D1A @a @b (MkD1 field _ :: D1 a b) = field
+    infixr 5 type `D1B`
+    infixr 5 type `D1A`
+    infix 5 type `PC1`
     type M1Sym0 :: forall a b. (~>) a ((~>) b Bool)
     data M1Sym0 :: (~>) a ((~>) b Bool)
       where
         M1Sym0KindInference :: SameKind (Apply M1Sym0 arg) (M1Sym1 arg) =>
                                M1Sym0 a0123456789876543210
-    type instance Apply M1Sym0 a0123456789876543210 = M1Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b Bool) M1Sym0 a0123456789876543210 = M1Sym1 a0123456789876543210
     instance SuppressUnusedWarnings M1Sym0 where
-      suppressUnusedWarnings = snd (((,) M1Sym0KindInference) ())
-    infix 6 `M1Sym0`
+      suppressUnusedWarnings = snd ((,) M1Sym0KindInference ())
+    infix 6 type `M1Sym0`
     type M1Sym1 :: forall a b. a -> (~>) b Bool
     data M1Sym1 (a0123456789876543210 :: a) :: (~>) b Bool
       where
         M1Sym1KindInference :: SameKind (Apply (M1Sym1 a0123456789876543210) arg) (M1Sym2 a0123456789876543210 arg) =>
                                M1Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (M1Sym1 a0123456789876543210) a0123456789876543210 = M1 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @Bool (M1Sym1 a0123456789876543210) a0123456789876543210 = M1 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (M1Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) M1Sym1KindInference) ())
-    infix 6 `M1Sym1`
+      suppressUnusedWarnings = snd ((,) M1Sym1KindInference ())
+    infix 6 type `M1Sym1`
     type M1Sym2 :: forall a b. a -> b -> Bool
-    type family M1Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Bool where
+    type family M1Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Bool where
       M1Sym2 a0123456789876543210 a0123456789876543210 = M1 a0123456789876543210 a0123456789876543210
-    infix 6 `M1Sym2`
+    infix 6 type `M1Sym2`
     class PC1 a b where
       type family M1 (arg :: a) (arg :: b) :: Bool
-      infix 6 `M1`
-    infixr 5 `sD1B`
-    infixr 5 `sD1A`
-    infixr 5 `SMkD1`
-    infix 5 `SC1`
-    sD1B ::
-      forall a b (t :: D1 a b). Sing t -> Sing (Apply D1BSym0 t :: b)
-    sD1A ::
-      forall a b (t :: D1 a b). Sing t -> Sing (Apply D1ASym0 t :: a)
+      infix 6 type `M1`
+    infixr 5 data `sD1B`
+    infixr 5 data `sD1A`
+    infixr 5 data `SMkD1`
+    infix 5 type `SC1`
+    sD1B :: forall a b (t :: D1 a b). Sing t -> Sing (D1B t :: b)
+    sD1A :: forall a b (t :: D1 a b). Sing t -> Sing (D1A t :: a)
     sD1B (SMkD1 _ (sField :: Sing field)) = sField
     sD1A (SMkD1 (sField :: Sing field) _) = sField
     instance SingI (D1BSym0 :: (~>) (D1 a b) b) where
-      sing = (singFun1 @D1BSym0) sD1B
+      sing = singFun1 @D1BSym0 sD1B
     instance SingI (D1ASym0 :: (~>) (D1 a b) a) where
-      sing = (singFun1 @D1ASym0) sD1A
+      sing = singFun1 @D1ASym0 sD1A
     data SD1 :: forall a b. D1 a b -> Type
       where
         SMkD1 :: forall a b (n :: a) (n :: b).
@@ -167,233 +165,217 @@
     type instance Sing @(D1 a b) = SD1
     instance (SingKind a, SingKind b) => SingKind (D1 a b) where
       type Demote (D1 a b) = D1 (Demote a) (Demote b)
-      fromSing (SMkD1 b b) = (MkD1 (fromSing b)) (fromSing b)
+      fromSing (SMkD1 b b) = MkD1 (fromSing b) (fromSing b)
       toSing (MkD1 (b :: Demote a) (b :: Demote b))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkD1 c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SMkD1 c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
     class SC1 a b where
       sM1 ::
-        forall (t :: a) (t :: b). Sing t
-                                  -> Sing t -> Sing (Apply (Apply M1Sym0 t) t :: Bool)
-      infix 6 `sM1`
+        (forall (t :: a) (t :: b).
+         Sing t -> Sing t -> Sing (M1 t t :: Bool) :: Type)
+      infix 6 data `sM1`
     instance (SingI n, SingI n) => SingI (MkD1 (n :: a) (n :: b)) where
-      sing = (SMkD1 sing) sing
+      sing = SMkD1 sing sing
     instance SingI n => SingI1 (MkD1 (n :: a)) where
       liftSing = SMkD1 sing
     instance SingI2 MkD1 where
       liftSing2 = SMkD1
     instance SingI (MkD1Sym0 :: (~>) a ((~>) b (D1 a b))) where
-      sing = (singFun2 @MkD1Sym0) SMkD1
+      sing = singFun2 @MkD1Sym0 SMkD1
     instance SingI d =>
              SingI (MkD1Sym1 (d :: a) :: (~>) b (D1 a b)) where
-      sing = (singFun1 @(MkD1Sym1 (d :: a))) (SMkD1 (sing @d))
+      sing = singFun1 @(MkD1Sym1 (d :: a)) (SMkD1 (sing @d))
     instance SingI1 (MkD1Sym1 :: a -> (~>) b (D1 a b)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(MkD1Sym1 (d :: a))) (SMkD1 s)
+        = singFun1 @(MkD1Sym1 (d :: a)) (SMkD1 s)
     instance SC1 a b => SingI (M1Sym0 :: (~>) a ((~>) b Bool)) where
-      sing = (singFun2 @M1Sym0) sM1
+      sing = singFun2 @M1Sym0 sM1
     instance (SC1 a b, SingI d) =>
              SingI (M1Sym1 (d :: a) :: (~>) b Bool) where
-      sing = (singFun1 @(M1Sym1 (d :: a))) (sM1 (sing @d))
+      sing = singFun1 @(M1Sym1 (d :: a)) (sM1 (sing @d))
     instance SC1 a b => SingI1 (M1Sym1 :: a -> (~>) b Bool) where
-      liftSing (s :: Sing (d :: a))
-        = (singFun1 @(M1Sym1 (d :: a))) (sM1 s)
+      liftSing (s :: Sing (d :: a)) = singFun1 @(M1Sym1 (d :: a)) (sM1 s)
 Singletons/T412.hs:0:0:: Splicing declarations
     genSingletons [''C2, ''T2a, ''T2b, ''D2]
   ======>
-    type M2Sym0 :: forall a b. (~>) a ((~>) b Bool)
+    type M2Sym0 :: forall (a :: Type) (b :: Type). (~>) a ((~>) b Bool)
     data M2Sym0 :: (~>) a ((~>) b Bool)
       where
         M2Sym0KindInference :: SameKind (Apply M2Sym0 arg) (M2Sym1 arg) =>
                                M2Sym0 a0123456789876543210
-    type instance Apply M2Sym0 a0123456789876543210 = M2Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b Bool) M2Sym0 a0123456789876543210 = M2Sym1 a0123456789876543210
     instance SuppressUnusedWarnings M2Sym0 where
-      suppressUnusedWarnings = snd (((,) M2Sym0KindInference) ())
-    infix 6 `M2Sym0`
-    type M2Sym1 :: forall a b. a -> (~>) b Bool
+      suppressUnusedWarnings = snd ((,) M2Sym0KindInference ())
+    infix 6 type `M2Sym0`
+    type M2Sym1 :: forall (a :: Type) (b :: Type). a -> (~>) b Bool
     data M2Sym1 (a0123456789876543210 :: a) :: (~>) b Bool
       where
         M2Sym1KindInference :: SameKind (Apply (M2Sym1 a0123456789876543210) arg) (M2Sym2 a0123456789876543210 arg) =>
                                M2Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (M2Sym1 a0123456789876543210) a0123456789876543210 = M2 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @Bool (M2Sym1 a0123456789876543210) a0123456789876543210 = M2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (M2Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) M2Sym1KindInference) ())
-    infix 6 `M2Sym1`
-    type M2Sym2 :: forall a b. a -> b -> Bool
-    type family M2Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Bool where
+      suppressUnusedWarnings = snd ((,) M2Sym1KindInference ())
+    infix 6 type `M2Sym1`
+    type M2Sym2 :: forall (a :: Type) (b :: Type). a -> b -> Bool
+    type family M2Sym2 @(a :: Type) @(b :: Type) (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Bool where
       M2Sym2 a0123456789876543210 a0123456789876543210 = M2 a0123456789876543210 a0123456789876543210
-    infix 6 `M2Sym2`
+    infix 6 type `M2Sym2`
     type PC2 :: Type -> Type -> Constraint
     class PC2 (a :: Type) (b :: Type) where
       type family M2 (arg :: a) (arg :: b) :: Bool
-    infix 5 `PC2`
-    infix 6 `M2`
+    infix 5 type `PC2`
+    infix 6 type `M2`
     class SC2 (a :: Type) (b :: Type) where
       sM2 ::
-        forall (t :: a) (t :: b). Sing t
-                                  -> Sing t -> Sing (Apply (Apply M2Sym0 t) t :: Bool)
+        (forall (t :: a) (t :: b).
+         Sing t -> Sing t -> Sing (M2 t t :: Bool) :: Type)
     type SC2 :: Type -> Type -> Constraint
-    infix 5 `SC2`
-    infix 6 `sM2`
+    infix 5 type `SC2`
+    infix 6 data `sM2`
     instance SC2 a b => SingI (M2Sym0 :: (~>) a ((~>) b Bool)) where
-      sing = (singFun2 @M2Sym0) sM2
+      sing = singFun2 @M2Sym0 sM2
     instance (SC2 a b, SingI d) =>
              SingI (M2Sym1 (d :: a) :: (~>) b Bool) where
-      sing = (singFun1 @(M2Sym1 (d :: a))) (sM2 (sing @d))
+      sing = singFun1 @(M2Sym1 (d :: a)) (sM2 (sing @d))
     instance SC2 a b => SingI1 (M2Sym1 :: a -> (~>) b Bool) where
-      liftSing (s :: Sing (d :: a))
-        = (singFun1 @(M2Sym1 (d :: a))) (sM2 s)
+      liftSing (s :: Sing (d :: a)) = singFun1 @(M2Sym1 (d :: a)) (sM2 s)
     type T2aSym0 :: (~>) Type ((~>) Type Type)
     data T2aSym0 :: (~>) Type ((~>) Type Type)
       where
         T2aSym0KindInference :: SameKind (Apply T2aSym0 arg) (T2aSym1 arg) =>
                                 T2aSym0 a0123456789876543210
-    type instance Apply T2aSym0 a0123456789876543210 = T2aSym1 a0123456789876543210
+    type instance Apply @Type @((~>) Type Type) T2aSym0 a0123456789876543210 = T2aSym1 a0123456789876543210
     instance SuppressUnusedWarnings T2aSym0 where
-      suppressUnusedWarnings = snd (((,) T2aSym0KindInference) ())
-    infixl 5 `T2aSym0`
+      suppressUnusedWarnings = snd ((,) T2aSym0KindInference ())
+    infixl 5 type `T2aSym0`
     type T2aSym1 :: Type -> (~>) Type Type
     data T2aSym1 (a0123456789876543210 :: Type) :: (~>) Type Type
       where
         T2aSym1KindInference :: SameKind (Apply (T2aSym1 a0123456789876543210) arg) (T2aSym2 a0123456789876543210 arg) =>
                                 T2aSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (T2aSym1 a0123456789876543210) a0123456789876543210 = T2a a0123456789876543210 a0123456789876543210
+    type instance Apply @Type @Type (T2aSym1 a0123456789876543210) a0123456789876543210 = T2a a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (T2aSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) T2aSym1KindInference) ())
-    infixl 5 `T2aSym1`
+      suppressUnusedWarnings = snd ((,) T2aSym1KindInference ())
+    infixl 5 type `T2aSym1`
     type T2aSym2 :: Type -> Type -> Type
     type family T2aSym2 (a0123456789876543210 :: Type) (a0123456789876543210 :: Type) :: Type where
       T2aSym2 a0123456789876543210 a0123456789876543210 = T2a a0123456789876543210 a0123456789876543210
-    infixl 5 `T2aSym2`
+    infixl 5 type `T2aSym2`
     type T2bSym0 :: (~>) Type ((~>) Type Type)
     data T2bSym0 :: (~>) Type ((~>) Type Type)
       where
         T2bSym0KindInference :: SameKind (Apply T2bSym0 arg) (T2bSym1 arg) =>
                                 T2bSym0 a0123456789876543210
-    type instance Apply T2bSym0 a0123456789876543210 = T2bSym1 a0123456789876543210
+    type instance Apply @Type @((~>) Type Type) T2bSym0 a0123456789876543210 = T2bSym1 a0123456789876543210
     instance SuppressUnusedWarnings T2bSym0 where
-      suppressUnusedWarnings = snd (((,) T2bSym0KindInference) ())
-    infixl 5 `T2bSym0`
+      suppressUnusedWarnings = snd ((,) T2bSym0KindInference ())
+    infixl 5 type `T2bSym0`
     type T2bSym1 :: Type -> (~>) Type Type
     data T2bSym1 (a0123456789876543210 :: Type) :: (~>) Type Type
       where
         T2bSym1KindInference :: SameKind (Apply (T2bSym1 a0123456789876543210) arg) (T2bSym2 a0123456789876543210 arg) =>
                                 T2bSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (T2bSym1 a0123456789876543210) a0123456789876543210 = T2b a0123456789876543210 a0123456789876543210
+    type instance Apply @Type @Type (T2bSym1 a0123456789876543210) a0123456789876543210 = T2b a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (T2bSym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) T2bSym1KindInference) ())
-    infixl 5 `T2bSym1`
+      suppressUnusedWarnings = snd ((,) T2bSym1KindInference ())
+    infixl 5 type `T2bSym1`
     type T2bSym2 :: Type -> Type -> Type
     type family T2bSym2 (a0123456789876543210 :: Type) (a0123456789876543210 :: Type) :: Type where
       T2bSym2 a0123456789876543210 a0123456789876543210 = T2b a0123456789876543210 a0123456789876543210
-    infixl 5 `T2bSym2`
+    infixl 5 type `T2bSym2`
     type MkD2Sym0 :: forall (a :: Type)
-                            (b :: Type). (~>) a ((~>) b (D2 (a :: Type) (b :: Type)))
-    data MkD2Sym0 :: (~>) a ((~>) b (D2 (a :: Type) (b :: Type)))
+                            (b :: Type). (~>) a ((~>) b (D2 a b))
+    data MkD2Sym0 :: (~>) a ((~>) b (D2 a b))
       where
         MkD2Sym0KindInference :: SameKind (Apply MkD2Sym0 arg) (MkD2Sym1 arg) =>
                                  MkD2Sym0 a0123456789876543210
-    type instance Apply MkD2Sym0 a0123456789876543210 = MkD2Sym1 a0123456789876543210
+    type instance Apply @a @((~>) b (D2 a b)) MkD2Sym0 a0123456789876543210 = MkD2Sym1 a0123456789876543210
     instance SuppressUnusedWarnings MkD2Sym0 where
-      suppressUnusedWarnings = snd (((,) MkD2Sym0KindInference) ())
-    infixr 5 `MkD2Sym0`
+      suppressUnusedWarnings = snd ((,) MkD2Sym0KindInference ())
+    infixr 5 type `MkD2Sym0`
     type MkD2Sym1 :: forall (a :: Type) (b :: Type). a
-                                                     -> (~>) b (D2 (a :: Type) (b :: Type))
-    data MkD2Sym1 (a0123456789876543210 :: a) :: (~>) b (D2 (a :: Type) (b :: Type))
+                                                     -> (~>) b (D2 a b)
+    data MkD2Sym1 (a0123456789876543210 :: a) :: (~>) b (D2 a b)
       where
         MkD2Sym1KindInference :: SameKind (Apply (MkD2Sym1 a0123456789876543210) arg) (MkD2Sym2 a0123456789876543210 arg) =>
                                  MkD2Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (MkD2Sym1 a0123456789876543210) a0123456789876543210 = 'MkD2 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @(D2 a b) (MkD2Sym1 a0123456789876543210) a0123456789876543210 = 'MkD2 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (MkD2Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) MkD2Sym1KindInference) ())
-    infixr 5 `MkD2Sym1`
-    type MkD2Sym2 :: forall (a :: Type) (b :: Type). a
-                                                     -> b -> D2 (a :: Type) (b :: Type)
-    type family MkD2Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: D2 (a :: Type) (b :: Type) where
+      suppressUnusedWarnings = snd ((,) MkD2Sym1KindInference ())
+    infixr 5 type `MkD2Sym1`
+    type MkD2Sym2 :: forall (a :: Type) (b :: Type). a -> b -> D2 a b
+    type family MkD2Sym2 @(a :: Type) @(b :: Type) (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: D2 a b where
       MkD2Sym2 a0123456789876543210 a0123456789876543210 = 'MkD2 a0123456789876543210 a0123456789876543210
-    infixr 5 `MkD2Sym2`
-    infixr 5 `D2A`
-    infixr 5 `D2B`
-    type D2BSym0 :: forall (a :: Type)
-                           (b :: Type). (~>) (D2 (a :: Type) (b :: Type)) b
-    data D2BSym0 :: (~>) (D2 (a :: Type) (b :: Type)) b
+    infixr 5 type `MkD2Sym2`
+    infixr 5 type `D2A`
+    infixr 5 type `D2B`
+    type D2BSym0 :: forall (a :: Type) (b :: Type). (~>) (D2 a b) b
+    data D2BSym0 :: (~>) (D2 a b) b
       where
         D2BSym0KindInference :: SameKind (Apply D2BSym0 arg) (D2BSym1 arg) =>
                                 D2BSym0 a0123456789876543210
-    type instance Apply D2BSym0 a0123456789876543210 = D2B a0123456789876543210
+    type instance Apply @(D2 a b) @b D2BSym0 a0123456789876543210 = D2B a0123456789876543210
     instance SuppressUnusedWarnings D2BSym0 where
-      suppressUnusedWarnings = snd (((,) D2BSym0KindInference) ())
-    type D2BSym1 :: forall (a :: Type)
-                           (b :: Type). D2 (a :: Type) (b :: Type) -> b
-    type family D2BSym1 (a0123456789876543210 :: D2 (a :: Type) (b :: Type)) :: b where
+      suppressUnusedWarnings = snd ((,) D2BSym0KindInference ())
+    type D2BSym1 :: forall (a :: Type) (b :: Type). D2 a b -> b
+    type family D2BSym1 @(a :: Type) @(b :: Type) (a0123456789876543210 :: D2 a b) :: b where
       D2BSym1 a0123456789876543210 = D2B a0123456789876543210
-    type D2ASym0 :: forall (a :: Type)
-                           (b :: Type). (~>) (D2 (a :: Type) (b :: Type)) a
-    data D2ASym0 :: (~>) (D2 (a :: Type) (b :: Type)) a
+    type D2ASym0 :: forall (a :: Type) (b :: Type). (~>) (D2 a b) a
+    data D2ASym0 :: (~>) (D2 a b) a
       where
         D2ASym0KindInference :: SameKind (Apply D2ASym0 arg) (D2ASym1 arg) =>
                                 D2ASym0 a0123456789876543210
-    type instance Apply D2ASym0 a0123456789876543210 = D2A a0123456789876543210
+    type instance Apply @(D2 a b) @a D2ASym0 a0123456789876543210 = D2A a0123456789876543210
     instance SuppressUnusedWarnings D2ASym0 where
-      suppressUnusedWarnings = snd (((,) D2ASym0KindInference) ())
-    type D2ASym1 :: forall (a :: Type)
-                           (b :: Type). D2 (a :: Type) (b :: Type) -> a
-    type family D2ASym1 (a0123456789876543210 :: D2 (a :: Type) (b :: Type)) :: a where
+      suppressUnusedWarnings = snd ((,) D2ASym0KindInference ())
+    type D2ASym1 :: forall (a :: Type) (b :: Type). D2 a b -> a
+    type family D2ASym1 @(a :: Type) @(b :: Type) (a0123456789876543210 :: D2 a b) :: a where
       D2ASym1 a0123456789876543210 = D2A a0123456789876543210
-    type D2B :: forall (a :: Type)
-                       (b :: Type). D2 (a :: Type) (b :: Type) -> b
-    type family D2B (a :: D2 (a :: Type) (b :: Type)) :: b where
-      D2B ('MkD2 _ field) = field
-    type D2A :: forall (a :: Type)
-                       (b :: Type). D2 (a :: Type) (b :: Type) -> a
-    type family D2A (a :: D2 (a :: Type) (b :: Type)) :: a where
-      D2A ('MkD2 field _) = field
+    type D2B :: forall (a :: Type) (b :: Type). D2 a b -> b
+    type family D2B @(a :: Type) @(b :: Type) (a :: D2 a b) :: b where
+      D2B @a @b ('MkD2 _ field :: D2 a b) = field
+    type D2A :: forall (a :: Type) (b :: Type). D2 a b -> a
+    type family D2A @(a :: Type) @(b :: Type) (a :: D2 a b) :: a where
+      D2A @a @b ('MkD2 field _ :: D2 a b) = field
     sD2B ::
-      forall (a :: Type)
-             (b :: Type)
-             (t :: D2 (a :: Type) (b :: Type)). Sing t
-                                                -> Sing (Apply D2BSym0 t :: b)
+      forall (a :: Type) (b :: Type) (t :: D2 a b). Sing t
+                                                    -> Sing (D2B t :: b)
     sD2A ::
-      forall (a :: Type)
-             (b :: Type)
-             (t :: D2 (a :: Type) (b :: Type)). Sing t
-                                                -> Sing (Apply D2ASym0 t :: a)
+      forall (a :: Type) (b :: Type) (t :: D2 a b). Sing t
+                                                    -> Sing (D2A t :: a)
     sD2B (SMkD2 _ (sField :: Sing field)) = sField
     sD2A (SMkD2 (sField :: Sing field) _) = sField
-    instance SingI (D2BSym0 :: (~>) (D2 (a :: Type) (b :: Type)) b) where
-      sing = (singFun1 @D2BSym0) sD2B
-    instance SingI (D2ASym0 :: (~>) (D2 (a :: Type) (b :: Type)) a) where
-      sing = (singFun1 @D2ASym0) sD2A
+    instance SingI (D2BSym0 :: (~>) (D2 a b) b) where
+      sing = singFun1 @D2BSym0 sD2B
+    instance SingI (D2ASym0 :: (~>) (D2 a b) a) where
+      sing = singFun1 @D2ASym0 sD2A
     type SD2 :: forall (a :: Type) (b :: Type). D2 a b -> Type
     data SD2 :: forall (a :: Type) (b :: Type). D2 a b -> Type
       where
         SMkD2 :: forall (a :: Type) (b :: Type) (n :: a) (n :: b).
-                 (Sing n) ->
-                 (Sing n) ->
-                 SD2 ('MkD2 n n :: D2 (a :: Type) (b :: Type))
+                 (Sing n) -> (Sing n) -> SD2 ('MkD2 n n :: D2 a b)
     type instance Sing @(D2 a b) = SD2
     instance (SingKind a, SingKind b) => SingKind (D2 a b) where
       type Demote (D2 a b) = D2 (Demote a) (Demote b)
-      fromSing (SMkD2 b b) = (MkD2 (fromSing b)) (fromSing b)
+      fromSing (SMkD2 b b) = MkD2 (fromSing b) (fromSing b)
       toSing (MkD2 (b :: Demote a) (b :: Demote b))
-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkD2 c) c)
-    infixr 5 `SMkD2`
-    infixr 5 `sD2A`
-    infixr 5 `sD2B`
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SMkD2 c c))
+            (toSing b :: SomeSing a) (toSing b :: SomeSing b)
+    infixr 5 data `SMkD2`
+    infixr 5 data `sD2A`
+    infixr 5 data `sD2B`
     instance (SingI n, SingI n) =>
              SingI ('MkD2 (n :: a) (n :: b)) where
-      sing = (SMkD2 sing) sing
+      sing = SMkD2 sing sing
     instance SingI n => SingI1 ('MkD2 (n :: a)) where
       liftSing = SMkD2 sing
     instance SingI2 'MkD2 where
       liftSing2 = SMkD2
-    instance SingI (MkD2Sym0 :: (~>) a ((~>) b (D2 (a :: Type) (b :: Type)))) where
-      sing = (singFun2 @MkD2Sym0) SMkD2
+    instance SingI (MkD2Sym0 :: (~>) a ((~>) b (D2 a b))) where
+      sing = singFun2 @MkD2Sym0 SMkD2
     instance SingI d =>
-             SingI (MkD2Sym1 (d :: a) :: (~>) b (D2 (a :: Type) (b :: Type))) where
-      sing = (singFun1 @(MkD2Sym1 (d :: a))) (SMkD2 (sing @d))
-    instance SingI1 (MkD2Sym1 :: a
-                                 -> (~>) b (D2 (a :: Type) (b :: Type))) where
+             SingI (MkD2Sym1 (d :: a) :: (~>) b (D2 a b)) where
+      sing = singFun1 @(MkD2Sym1 (d :: a)) (SMkD2 (sing @d))
+    instance SingI1 (MkD2Sym1 :: a -> (~>) b (D2 a b)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @(MkD2Sym1 (d :: a))) (SMkD2 s)
+        = singFun1 @(MkD2Sym1 (d :: a)) (SMkD2 s)
diff --git a/tests/compile-and-dump/Singletons/T414.golden b/tests/compile-and-dump/Singletons/T414.golden
--- a/tests/compile-and-dump/Singletons/T414.golden
+++ b/tests/compile-and-dump/Singletons/T414.golden
@@ -20,16 +20,16 @@
       where
         T1Sym0KindInference :: SameKind (Apply T1Sym0 arg) (T1Sym1 arg) =>
                                T1Sym0 a0123456789876543210
-    type instance Apply T1Sym0 a0123456789876543210 = T1Sym1 a0123456789876543210
+    type instance Apply @Bool @_ T1Sym0 a0123456789876543210 = T1Sym1 a0123456789876543210
     instance SuppressUnusedWarnings T1Sym0 where
-      suppressUnusedWarnings = snd (((,) T1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) T1Sym0KindInference ())
     data T1Sym1 (a0123456789876543210 :: Bool) b0123456789876543210
       where
         T1Sym1KindInference :: SameKind (Apply (T1Sym1 a0123456789876543210) arg) (T1Sym2 a0123456789876543210 arg) =>
                                T1Sym1 a0123456789876543210 b0123456789876543210
-    type instance Apply (T1Sym1 a0123456789876543210) b0123456789876543210 = T1 a0123456789876543210 b0123456789876543210
+    type instance Apply @_ @_ (T1Sym1 a0123456789876543210) b0123456789876543210 = T1 a0123456789876543210 b0123456789876543210
     instance SuppressUnusedWarnings (T1Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) T1Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) T1Sym1KindInference ())
     type family T1Sym2 (a0123456789876543210 :: Bool) b0123456789876543210 where
       T1Sym2 a0123456789876543210 b0123456789876543210 = T1 a0123456789876543210 b0123456789876543210
     class PC1 (a :: Bool)
@@ -37,16 +37,16 @@
       where
         T2Sym0KindInference :: SameKind (Apply T2Sym0 arg) (T2Sym1 arg) =>
                                T2Sym0 a0123456789876543210
-    type instance Apply T2Sym0 a0123456789876543210 = T2Sym1 a0123456789876543210
+    type instance Apply @_ @_ T2Sym0 a0123456789876543210 = T2Sym1 a0123456789876543210
     instance SuppressUnusedWarnings T2Sym0 where
-      suppressUnusedWarnings = snd (((,) T2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) T2Sym0KindInference ())
     data T2Sym1 a0123456789876543210 b0123456789876543210
       where
         T2Sym1KindInference :: SameKind (Apply (T2Sym1 a0123456789876543210) arg) (T2Sym2 a0123456789876543210 arg) =>
                                T2Sym1 a0123456789876543210 b0123456789876543210
-    type instance Apply (T2Sym1 a0123456789876543210) b0123456789876543210 = T2 a0123456789876543210 b0123456789876543210
+    type instance Apply @_ @_ (T2Sym1 a0123456789876543210) b0123456789876543210 = T2 a0123456789876543210 b0123456789876543210
     instance SuppressUnusedWarnings (T2Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) T2Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) T2Sym1KindInference ())
     type family T2Sym2 a0123456789876543210 b0123456789876543210 where
       T2Sym2 a0123456789876543210 b0123456789876543210 = T2 a0123456789876543210 b0123456789876543210
     class PC2 a
@@ -55,17 +55,17 @@
       where
         T3Sym0KindInference :: SameKind (Apply T3Sym0 arg) (T3Sym1 arg) =>
                                T3Sym0 a0123456789876543210
-    type instance Apply T3Sym0 a0123456789876543210 = T3Sym1 a0123456789876543210
+    type instance Apply @Bool @((~>) Type Type) T3Sym0 a0123456789876543210 = T3Sym1 a0123456789876543210
     instance SuppressUnusedWarnings T3Sym0 where
-      suppressUnusedWarnings = snd (((,) T3Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) T3Sym0KindInference ())
     type T3Sym1 :: Bool -> (~>) Type Type
     data T3Sym1 (a0123456789876543210 :: Bool) :: (~>) Type Type
       where
         T3Sym1KindInference :: SameKind (Apply (T3Sym1 a0123456789876543210) arg) (T3Sym2 a0123456789876543210 arg) =>
                                T3Sym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (T3Sym1 a0123456789876543210) a0123456789876543210 = T3 a0123456789876543210 a0123456789876543210
+    type instance Apply @Type @Type (T3Sym1 a0123456789876543210) a0123456789876543210 = T3 a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (T3Sym1 a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) T3Sym1KindInference) ())
+      suppressUnusedWarnings = snd ((,) T3Sym1KindInference ())
     type T3Sym2 :: Bool -> Type -> Type
     type family T3Sym2 (a0123456789876543210 :: Bool) (a0123456789876543210 :: Type) :: Type where
       T3Sym2 a0123456789876543210 a0123456789876543210 = T3 a0123456789876543210 a0123456789876543210
diff --git a/tests/compile-and-dump/Singletons/T433.golden b/tests/compile-and-dump/Singletons/T433.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T433.golden
@@ -0,0 +1,285 @@
+Singletons/T433.hs:(0,0)-(0,0): Splicing declarations
+    promote
+      [d| konst1 :: a -> Bool -> a
+          konst1 x _ = x
+          konst2 :: a -> Maybe Bool -> a
+          konst2 x _ = x
+          f local
+            = g
+            where
+                g :: forall a. a -> a
+                g x = konst1 (x :: a) local
+          foo :: forall a. a -> ()
+          foo x = const () (Nothing :: Maybe a)
+          id2 :: forall a. a -> a
+          id2 x = id (x :: a)
+          id3 :: a -> a
+          id3 (x :: b) = id (x :: b)
+          id4 :: forall a. a -> a
+          id4 (x :: a) = id (x :: a)
+          id5 :: forall a. a -> a
+          id5
+            = g
+            where
+                g = id :: a -> a
+          id6 :: a -> a
+          id6 (x :: b)
+            = g
+            where
+                g = (x :: b)
+          id7 (x :: b)
+            = g
+            where
+                g = (x :: b)
+          id8 :: a -> a
+          id8 x
+            = g x True
+            where
+                g :: b -> a -> b
+                g y _ = y |]
+  ======>
+    konst1 :: a -> Bool -> a
+    konst1 x _ = x
+    konst2 :: a -> Maybe Bool -> a
+    konst2 x _ = x
+    f local
+      = g
+      where
+          g :: forall a. a -> a
+          g x = konst1 (x :: a) local
+    foo :: forall a. a -> ()
+    foo x = const () (Nothing :: Maybe a)
+    id2 :: forall a. a -> a
+    id2 x = id (x :: a)
+    id3 :: a -> a
+    id3 (x :: b) = id (x :: b)
+    id4 :: forall a. a -> a
+    id4 (x :: a) = id (x :: a)
+    id5 :: forall a. a -> a
+    id5
+      = g
+      where
+          g = id :: a -> a
+    id6 :: a -> a
+    id6 (x :: b)
+      = g
+      where
+          g = x :: b
+    id7 (x :: b)
+      = g
+      where
+          g = x :: b
+    id8 :: a -> a
+    id8 x
+      = g x True
+      where
+          g :: b -> a -> b
+          g y _ = y
+    data Let0123456789876543210GSym0 (x0123456789876543210 :: a0123456789876543210) :: (~>) b0123456789876543210 ((~>) a0123456789876543210 b0123456789876543210)
+      where
+        Let0123456789876543210GSym0KindInference :: SameKind (Apply (Let0123456789876543210GSym0 x0123456789876543210) arg) (Let0123456789876543210GSym1 x0123456789876543210 arg) =>
+                                                    Let0123456789876543210GSym0 x0123456789876543210 a0123456789876543210
+    type instance Apply @b0123456789876543210 @((~>) a0123456789876543210 b0123456789876543210) (Let0123456789876543210GSym0 x0123456789876543210) a0123456789876543210 = Let0123456789876543210GSym1 x0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Let0123456789876543210GSym0 x0123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) Let0123456789876543210GSym0KindInference ())
+    data Let0123456789876543210GSym1 (x0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) :: (~>) a0123456789876543210 b0123456789876543210
+      where
+        Let0123456789876543210GSym1KindInference :: SameKind (Apply (Let0123456789876543210GSym1 x0123456789876543210 a0123456789876543210) arg) (Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210 arg) =>
+                                                    Let0123456789876543210GSym1 x0123456789876543210 a0123456789876543210 a0123456789876543210
+    type instance Apply @a0123456789876543210 @b0123456789876543210 (Let0123456789876543210GSym1 x0123456789876543210 a0123456789876543210) a0123456789876543210 = Let0123456789876543210G x0123456789876543210 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Let0123456789876543210GSym1 x0123456789876543210 a0123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) Let0123456789876543210GSym1KindInference ())
+    type family Let0123456789876543210GSym2 (x0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) (a0123456789876543210 :: a0123456789876543210) :: b0123456789876543210 where
+      Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210 a0123456789876543210 = Let0123456789876543210G x0123456789876543210 a0123456789876543210 a0123456789876543210
+    type family Let0123456789876543210G (x0123456789876543210 :: a0123456789876543210) (a :: b) (a :: a) :: b where
+      Let0123456789876543210G x y _ = y
+    type family Let0123456789876543210GSym0 b0123456789876543210 (x0123456789876543210 :: b0123456789876543210) where
+      Let0123456789876543210GSym0 b0123456789876543210 x0123456789876543210 = Let0123456789876543210G b0123456789876543210 x0123456789876543210
+    type family Let0123456789876543210G b0123456789876543210 (x0123456789876543210 :: b0123456789876543210) where
+      Let0123456789876543210G b x = x :: b
+    type family Let0123456789876543210GSym0 b0123456789876543210 (x0123456789876543210 :: b0123456789876543210) where
+      Let0123456789876543210GSym0 b0123456789876543210 x0123456789876543210 = Let0123456789876543210G b0123456789876543210 x0123456789876543210
+    type family Let0123456789876543210G b0123456789876543210 (x0123456789876543210 :: b0123456789876543210) where
+      Let0123456789876543210G b x = x :: b
+    type family Let0123456789876543210GSym0 a0123456789876543210 (a_01234567898765432100123456789876543210 :: a0123456789876543210) where
+      Let0123456789876543210GSym0 a0123456789876543210 a_01234567898765432100123456789876543210 = Let0123456789876543210G a0123456789876543210 a_01234567898765432100123456789876543210
+    type family Let0123456789876543210G a0123456789876543210 (a_01234567898765432100123456789876543210 :: a0123456789876543210) where
+      Let0123456789876543210G a a_0123456789876543210 = IdSym0 :: (~>) a a
+    data Let0123456789876543210GSym0 local0123456789876543210 :: (~>) a0123456789876543210 a0123456789876543210
+      where
+        Let0123456789876543210GSym0KindInference :: SameKind (Apply (Let0123456789876543210GSym0 local0123456789876543210) arg) (Let0123456789876543210GSym1 local0123456789876543210 arg) =>
+                                                    Let0123456789876543210GSym0 local0123456789876543210 a0123456789876543210
+    type instance Apply @a0123456789876543210 @a0123456789876543210 (Let0123456789876543210GSym0 local0123456789876543210) a0123456789876543210 = Let0123456789876543210G local0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Let0123456789876543210GSym0 local0123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) Let0123456789876543210GSym0KindInference ())
+    type family Let0123456789876543210GSym1 local0123456789876543210 (a0123456789876543210 :: a0123456789876543210) :: a0123456789876543210 where
+      Let0123456789876543210GSym1 local0123456789876543210 a0123456789876543210 = Let0123456789876543210G local0123456789876543210 a0123456789876543210
+    type family Let0123456789876543210G local0123456789876543210 (a :: a) :: a where
+      Let0123456789876543210G local (x :: a) = Apply (Apply Konst1Sym0 (x :: a)) local
+    type Id8Sym0 :: (~>) a a
+    data Id8Sym0 :: (~>) a a
+      where
+        Id8Sym0KindInference :: SameKind (Apply Id8Sym0 arg) (Id8Sym1 arg) =>
+                                Id8Sym0 a0123456789876543210
+    type instance Apply @a @a Id8Sym0 a0123456789876543210 = Id8 a0123456789876543210
+    instance SuppressUnusedWarnings Id8Sym0 where
+      suppressUnusedWarnings = snd ((,) Id8Sym0KindInference ())
+    type Id8Sym1 :: a -> a
+    type family Id8Sym1 @a (a0123456789876543210 :: a) :: a where
+      Id8Sym1 a0123456789876543210 = Id8 a0123456789876543210
+    data Id7Sym0 a0123456789876543210
+      where
+        Id7Sym0KindInference :: SameKind (Apply Id7Sym0 arg) (Id7Sym1 arg) =>
+                                Id7Sym0 a0123456789876543210
+    type instance Apply @_ @_ Id7Sym0 a0123456789876543210 = Id7 a0123456789876543210
+    instance SuppressUnusedWarnings Id7Sym0 where
+      suppressUnusedWarnings = snd ((,) Id7Sym0KindInference ())
+    type family Id7Sym1 a0123456789876543210 where
+      Id7Sym1 a0123456789876543210 = Id7 a0123456789876543210
+    type Id6Sym0 :: (~>) a a
+    data Id6Sym0 :: (~>) a a
+      where
+        Id6Sym0KindInference :: SameKind (Apply Id6Sym0 arg) (Id6Sym1 arg) =>
+                                Id6Sym0 a0123456789876543210
+    type instance Apply @a @a Id6Sym0 a0123456789876543210 = Id6 a0123456789876543210
+    instance SuppressUnusedWarnings Id6Sym0 where
+      suppressUnusedWarnings = snd ((,) Id6Sym0KindInference ())
+    type Id6Sym1 :: a -> a
+    type family Id6Sym1 @a (a0123456789876543210 :: a) :: a where
+      Id6Sym1 a0123456789876543210 = Id6 a0123456789876543210
+    type Id5Sym0 :: forall a. (~>) a a
+    data Id5Sym0 :: (~>) a a
+      where
+        Id5Sym0KindInference :: SameKind (Apply Id5Sym0 arg) (Id5Sym1 arg) =>
+                                Id5Sym0 a0123456789876543210
+    type instance Apply @a @a Id5Sym0 a0123456789876543210 = Id5 a0123456789876543210
+    instance SuppressUnusedWarnings Id5Sym0 where
+      suppressUnusedWarnings = snd ((,) Id5Sym0KindInference ())
+    type Id5Sym1 :: forall a. a -> a
+    type family Id5Sym1 @a (a0123456789876543210 :: a) :: a where
+      Id5Sym1 a0123456789876543210 = Id5 a0123456789876543210
+    type Id4Sym0 :: forall a. (~>) a a
+    data Id4Sym0 :: (~>) a a
+      where
+        Id4Sym0KindInference :: SameKind (Apply Id4Sym0 arg) (Id4Sym1 arg) =>
+                                Id4Sym0 a0123456789876543210
+    type instance Apply @a @a Id4Sym0 a0123456789876543210 = Id4 a0123456789876543210
+    instance SuppressUnusedWarnings Id4Sym0 where
+      suppressUnusedWarnings = snd ((,) Id4Sym0KindInference ())
+    type Id4Sym1 :: forall a. a -> a
+    type family Id4Sym1 @a (a0123456789876543210 :: a) :: a where
+      Id4Sym1 a0123456789876543210 = Id4 a0123456789876543210
+    type Id3Sym0 :: (~>) a a
+    data Id3Sym0 :: (~>) a a
+      where
+        Id3Sym0KindInference :: SameKind (Apply Id3Sym0 arg) (Id3Sym1 arg) =>
+                                Id3Sym0 a0123456789876543210
+    type instance Apply @a @a Id3Sym0 a0123456789876543210 = Id3 a0123456789876543210
+    instance SuppressUnusedWarnings Id3Sym0 where
+      suppressUnusedWarnings = snd ((,) Id3Sym0KindInference ())
+    type Id3Sym1 :: a -> a
+    type family Id3Sym1 @a (a0123456789876543210 :: a) :: a where
+      Id3Sym1 a0123456789876543210 = Id3 a0123456789876543210
+    type Id2Sym0 :: forall a. (~>) a a
+    data Id2Sym0 :: (~>) a a
+      where
+        Id2Sym0KindInference :: SameKind (Apply Id2Sym0 arg) (Id2Sym1 arg) =>
+                                Id2Sym0 a0123456789876543210
+    type instance Apply @a @a Id2Sym0 a0123456789876543210 = Id2 a0123456789876543210
+    instance SuppressUnusedWarnings Id2Sym0 where
+      suppressUnusedWarnings = snd ((,) Id2Sym0KindInference ())
+    type Id2Sym1 :: forall a. a -> a
+    type family Id2Sym1 @a (a0123456789876543210 :: a) :: a where
+      Id2Sym1 a0123456789876543210 = Id2 a0123456789876543210
+    type FooSym0 :: forall a. (~>) a ()
+    data FooSym0 :: (~>) a ()
+      where
+        FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
+                                FooSym0 a0123456789876543210
+    type instance Apply @a @() FooSym0 a0123456789876543210 = Foo a0123456789876543210
+    instance SuppressUnusedWarnings FooSym0 where
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
+    type FooSym1 :: forall a. a -> ()
+    type family FooSym1 @a (a0123456789876543210 :: a) :: () where
+      FooSym1 a0123456789876543210 = Foo a0123456789876543210
+    data FSym0 a0123456789876543210
+      where
+        FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
+                              FSym0 a0123456789876543210
+    type instance Apply @_ @_ FSym0 a0123456789876543210 = F a0123456789876543210
+    instance SuppressUnusedWarnings FSym0 where
+      suppressUnusedWarnings = snd ((,) FSym0KindInference ())
+    type family FSym1 a0123456789876543210 where
+      FSym1 a0123456789876543210 = F a0123456789876543210
+    type Konst2Sym0 :: (~>) a ((~>) (Maybe Bool) a)
+    data Konst2Sym0 :: (~>) a ((~>) (Maybe Bool) a)
+      where
+        Konst2Sym0KindInference :: SameKind (Apply Konst2Sym0 arg) (Konst2Sym1 arg) =>
+                                   Konst2Sym0 a0123456789876543210
+    type instance Apply @a @((~>) (Maybe Bool) a) Konst2Sym0 a0123456789876543210 = Konst2Sym1 a0123456789876543210
+    instance SuppressUnusedWarnings Konst2Sym0 where
+      suppressUnusedWarnings = snd ((,) Konst2Sym0KindInference ())
+    type Konst2Sym1 :: a -> (~>) (Maybe Bool) a
+    data Konst2Sym1 (a0123456789876543210 :: a) :: (~>) (Maybe Bool) a
+      where
+        Konst2Sym1KindInference :: SameKind (Apply (Konst2Sym1 a0123456789876543210) arg) (Konst2Sym2 a0123456789876543210 arg) =>
+                                   Konst2Sym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @(Maybe Bool) @a (Konst2Sym1 a0123456789876543210) a0123456789876543210 = Konst2 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Konst2Sym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) Konst2Sym1KindInference ())
+    type Konst2Sym2 :: a -> Maybe Bool -> a
+    type family Konst2Sym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe Bool) :: a where
+      Konst2Sym2 a0123456789876543210 a0123456789876543210 = Konst2 a0123456789876543210 a0123456789876543210
+    type Konst1Sym0 :: (~>) a ((~>) Bool a)
+    data Konst1Sym0 :: (~>) a ((~>) Bool a)
+      where
+        Konst1Sym0KindInference :: SameKind (Apply Konst1Sym0 arg) (Konst1Sym1 arg) =>
+                                   Konst1Sym0 a0123456789876543210
+    type instance Apply @a @((~>) Bool a) Konst1Sym0 a0123456789876543210 = Konst1Sym1 a0123456789876543210
+    instance SuppressUnusedWarnings Konst1Sym0 where
+      suppressUnusedWarnings = snd ((,) Konst1Sym0KindInference ())
+    type Konst1Sym1 :: a -> (~>) Bool a
+    data Konst1Sym1 (a0123456789876543210 :: a) :: (~>) Bool a
+      where
+        Konst1Sym1KindInference :: SameKind (Apply (Konst1Sym1 a0123456789876543210) arg) (Konst1Sym2 a0123456789876543210 arg) =>
+                                   Konst1Sym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @Bool @a (Konst1Sym1 a0123456789876543210) a0123456789876543210 = Konst1 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (Konst1Sym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) Konst1Sym1KindInference ())
+    type Konst1Sym2 :: a -> Bool -> a
+    type family Konst1Sym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: Bool) :: a where
+      Konst1Sym2 a0123456789876543210 a0123456789876543210 = Konst1 a0123456789876543210 a0123456789876543210
+    type Id8 :: a -> a
+    type family Id8 @a (a :: a) :: a where
+      Id8 x = Apply (Apply (Let0123456789876543210GSym0 x) x) TrueSym0
+    type family Id7 a where
+      Id7 (x :: b) = Let0123456789876543210GSym0 b x
+    type Id6 :: a -> a
+    type family Id6 @a (a :: a) :: a where
+      Id6 (x :: b) = Let0123456789876543210GSym0 b x
+    type Id5 :: forall a. a -> a
+    type family Id5 @a (a :: a) :: a where
+      Id5 @a (a_0123456789876543210 :: a) = Apply (Let0123456789876543210GSym0 a a_0123456789876543210) a_0123456789876543210
+    type Id4 :: forall a. a -> a
+    type family Id4 @a (a :: a) :: a where
+      Id4 @a (x :: a :: a) = Apply IdSym0 (x :: a)
+    type Id3 :: a -> a
+    type family Id3 @a (a :: a) :: a where
+      Id3 (x :: b) = Apply IdSym0 (x :: b)
+    type Id2 :: forall a. a -> a
+    type family Id2 @a (a :: a) :: a where
+      Id2 @a (x :: a) = Apply IdSym0 (x :: a)
+    type Foo :: forall a. a -> ()
+    type family Foo @a (a :: a) :: () where
+      Foo @a (x :: a) = Apply (Apply ConstSym0 Tuple0Sym0) (NothingSym0 :: Maybe a)
+    type family F a where
+      F local = Let0123456789876543210GSym0 local
+    type Konst2 :: a -> Maybe Bool -> a
+    type family Konst2 @a (a :: a) (a :: Maybe Bool) :: a where
+      Konst2 x _ = x
+    type Konst1 :: a -> Bool -> a
+    type family Konst1 @a (a :: a) (a :: Bool) :: a where
+      Konst1 x _ = x
diff --git a/tests/compile-and-dump/Singletons/T433.hs b/tests/compile-and-dump/Singletons/T433.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T433.hs
@@ -0,0 +1,72 @@
+module T433 where
+
+import Data.Kind (Type)
+import Data.Singletons.Base.TH
+import Prelude.Singletons
+
+$(promote [d|
+  konst1 :: a -> Bool -> a
+  konst1 x _ = x
+
+  konst2 :: a -> Maybe Bool -> a
+  konst2 x _ = x
+
+  f local = g
+    where
+      g :: forall a. a -> a
+      g x = konst1 (x :: a) local
+
+  foo :: forall a. a -> ()
+  foo x = const () (Nothing :: Maybe a)
+
+  id2 :: forall a. a -> a
+  id2 x = id (x :: a)
+
+  id3 :: a -> a
+  id3 (x :: b) = id (x :: b)
+
+  id4 :: forall a. a -> a
+  id4 (x :: a) = id (x :: a)
+
+  id5 :: forall a. a -> a
+  id5 = g
+    where
+      g = id :: a -> a
+
+  id6 :: a -> a
+  id6 (x :: b) = g
+    where
+      g = (x :: b)
+
+  id7 (x :: b) = g
+    where
+      g = (x :: b)
+
+  id8 :: a -> a
+  id8 x = g x True
+    where
+      g :: b -> a -> b
+      g y _ = y
+
+  -- These version will not work. See the singletons README for more about these
+  -- limitations.
+
+  -- This will not work because the `a` in `forall a` scopes over the body of
+  -- the function, but the `(x :: b)` pattern refers to `b` instead of `a`.
+  {-
+  id9 :: forall a. a -> a
+  id9 (x :: b) = id (x :: b)
+  -}
+
+  -- This will not work because the `b` in `Nothing :: Maybe b` is bound by the
+  -- type signature for `g`, a local variable that closes over `x`. Moreover,
+  -- `b` is only mentioned in the return type (and not the arguments) of the
+  -- type signature.
+  {-
+  id10 :: forall a. a -> a
+  id10 x = konst2 x y
+    where
+      y :: forall b. Maybe b
+      y = Nothing :: Maybe b
+  -}
+  |])
diff --git a/tests/compile-and-dump/Singletons/T443.golden b/tests/compile-and-dump/Singletons/T443.golden
--- a/tests/compile-and-dump/Singletons/T443.golden
+++ b/tests/compile-and-dump/Singletons/T443.golden
@@ -20,74 +20,73 @@
       where
         SSym0KindInference :: SameKind (Apply SSym0 arg) (SSym1 arg) =>
                               SSym0 a0123456789876543210
-    type instance Apply SSym0 a0123456789876543210 = S a0123456789876543210
+    type instance Apply @Nat @Nat SSym0 a0123456789876543210 = S a0123456789876543210
     instance SuppressUnusedWarnings SSym0 where
-      suppressUnusedWarnings = snd (((,) SSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) SSym0KindInference ())
     type SSym1 :: Nat -> Nat
     type family SSym1 (a0123456789876543210 :: Nat) :: Nat where
       SSym1 a0123456789876543210 = S a0123456789876543210
     type VNilSym0 :: Vec Z a
-    type family VNilSym0 :: Vec Z a where
+    type family VNilSym0 @a :: Vec Z a where
       VNilSym0 = VNil
     type (:>@#@$) :: (~>) a ((~>) (Vec n a) (Vec (S n) a))
     data (:>@#@$) :: (~>) a ((~>) (Vec n a) (Vec (S n) a))
       where
         (::>@#@$###) :: SameKind (Apply (:>@#@$) arg) ((:>@#@$$) arg) =>
                         (:>@#@$) a0123456789876543210
-    type instance Apply (:>@#@$) a0123456789876543210 = (:>@#@$$) a0123456789876543210
+    type instance Apply @a @((~>) (Vec n a) (Vec (S n) a)) (:>@#@$) a0123456789876543210 = (:>@#@$$) a0123456789876543210
     instance SuppressUnusedWarnings (:>@#@$) where
-      suppressUnusedWarnings = snd (((,) (::>@#@$###)) ())
+      suppressUnusedWarnings = snd ((,) (::>@#@$###) ())
     type (:>@#@$$) :: a -> (~>) (Vec n a) (Vec (S n) a)
     data (:>@#@$$) (a0123456789876543210 :: a) :: (~>) (Vec n a) (Vec (S n) a)
       where
         (::>@#@$$###) :: SameKind (Apply ((:>@#@$$) a0123456789876543210) arg) ((:>@#@$$$) a0123456789876543210 arg) =>
                          (:>@#@$$) a0123456789876543210 a0123456789876543210
-    type instance Apply ((:>@#@$$) a0123456789876543210) a0123456789876543210 = (:>) a0123456789876543210 a0123456789876543210
+    type instance Apply @(Vec n a) @(Vec (S n) a) ((:>@#@$$) a0123456789876543210) a0123456789876543210 = (:>) a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings ((:>@#@$$) a0123456789876543210) where
-      suppressUnusedWarnings = snd (((,) (::>@#@$$###)) ())
+      suppressUnusedWarnings = snd ((,) (::>@#@$$###) ())
     type (:>@#@$$$) :: a -> Vec n a -> Vec (S n) a
-    type family (:>@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: Vec n a) :: Vec (S n) a where
+    type family (:>@#@$$$) @a @n (a0123456789876543210 :: a) (a0123456789876543210 :: Vec n a) :: Vec (S n) a where
       (:>@#@$$$) a0123456789876543210 a0123456789876543210 = (:>) a0123456789876543210 a0123456789876543210
     type TailSym0 :: (~>) (Vec (S n) a) (Vec n a)
     data TailSym0 :: (~>) (Vec (S n) a) (Vec n a)
       where
         TailSym0KindInference :: SameKind (Apply TailSym0 arg) (TailSym1 arg) =>
                                  TailSym0 a0123456789876543210
-    type instance Apply TailSym0 a0123456789876543210 = Tail a0123456789876543210
+    type instance Apply @(Vec (S n) a) @(Vec n a) TailSym0 a0123456789876543210 = Tail a0123456789876543210
     instance SuppressUnusedWarnings TailSym0 where
-      suppressUnusedWarnings = snd (((,) TailSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) TailSym0KindInference ())
     type TailSym1 :: Vec (S n) a -> Vec n a
-    type family TailSym1 (a0123456789876543210 :: Vec (S n) a) :: Vec n a where
+    type family TailSym1 @n @a (a0123456789876543210 :: Vec (S n) a) :: Vec n a where
       TailSym1 a0123456789876543210 = Tail a0123456789876543210
     type HeadSym0 :: (~>) (Vec (S n) a) a
     data HeadSym0 :: (~>) (Vec (S n) a) a
       where
         HeadSym0KindInference :: SameKind (Apply HeadSym0 arg) (HeadSym1 arg) =>
                                  HeadSym0 a0123456789876543210
-    type instance Apply HeadSym0 a0123456789876543210 = Head a0123456789876543210
+    type instance Apply @(Vec (S n) a) @a HeadSym0 a0123456789876543210 = Head a0123456789876543210
     instance SuppressUnusedWarnings HeadSym0 where
-      suppressUnusedWarnings = snd (((,) HeadSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) HeadSym0KindInference ())
     type HeadSym1 :: Vec (S n) a -> a
-    type family HeadSym1 (a0123456789876543210 :: Vec (S n) a) :: a where
+    type family HeadSym1 @n @a (a0123456789876543210 :: Vec (S n) a) :: a where
       HeadSym1 a0123456789876543210 = Head a0123456789876543210
     type Tail :: Vec (S n) a -> Vec n a
-    type family Tail (a :: Vec (S n) a) :: Vec n a where
+    type family Tail @n @a (a :: Vec (S n) a) :: Vec n a where
       Tail ((:>) _ field) = field
     type Head :: Vec (S n) a -> a
-    type family Head (a :: Vec (S n) a) :: a where
+    type family Head @n @a (a :: Vec (S n) a) :: a where
       Head ((:>) field _) = field
     sTail ::
-      forall n a (t :: Vec (S n) a). Sing t
-                                     -> Sing (Apply TailSym0 t :: Vec n a)
+      (forall (t :: Vec (S n) a).
+       Sing t -> Sing (Tail t :: Vec n a) :: Type)
     sHead ::
-      forall n a (t :: Vec (S n) a). Sing t
-                                     -> Sing (Apply HeadSym0 t :: a)
+      (forall (t :: Vec (S n) a). Sing t -> Sing (Head t :: a) :: Type)
     sTail ((:%>) _ (sField :: Sing field)) = sField
     sHead ((:%>) (sField :: Sing field) _) = sField
     instance SingI (TailSym0 :: (~>) (Vec (S n) a) (Vec n a)) where
-      sing = (singFun1 @TailSym0) sTail
+      sing = singFun1 @TailSym0 sTail
     instance SingI (HeadSym0 :: (~>) (Vec (S n) a) a) where
-      sing = (singFun1 @HeadSym0) sHead
+      sing = singFun1 @HeadSym0 sHead
     data SNat :: Nat -> Type
       where
         SZ :: SNat (Z :: Nat)
@@ -106,22 +105,22 @@
     instance SingI1 S where
       liftSing = SS
     instance SingI (SSym0 :: (~>) Nat Nat) where
-      sing = (singFun1 @SSym0) SS
+      sing = singFun1 @SSym0 SS
     instance SingI VNil where
       sing = SVNil
     instance (SingI n, SingI n) =>
              SingI ((:>) (n :: a) (n :: Vec n a)) where
-      sing = ((:%>) sing) sing
+      sing = (:%>) sing sing
     instance SingI n => SingI1 ((:>) (n :: a)) where
       liftSing = (:%>) sing
     instance SingI2 (:>) where
       liftSing2 = (:%>)
     instance SingI ((:>@#@$) :: (~>) a ((~>) (Vec n a) (Vec (S n) a))) where
-      sing = (singFun2 @(:>@#@$)) (:%>)
+      sing = singFun2 @(:>@#@$) (:%>)
     instance SingI d =>
              SingI ((:>@#@$$) (d :: a) :: (~>) (Vec n a) (Vec (S n) a)) where
-      sing = (singFun1 @((:>@#@$$) (d :: a))) ((:%>) (sing @d))
+      sing = singFun1 @((:>@#@$$) (d :: a)) ((:%>) (sing @d))
     instance SingI1 ((:>@#@$$) :: a
                                   -> (~>) (Vec n a) (Vec (S n) a)) where
       liftSing (s :: Sing (d :: a))
-        = (singFun1 @((:>@#@$$) (d :: a))) ((:%>) s)
+        = singFun1 @((:>@#@$$) (d :: a)) ((:%>) s)
diff --git a/tests/compile-and-dump/Singletons/T445.golden b/tests/compile-and-dump/Singletons/T445.golden
--- a/tests/compile-and-dump/Singletons/T445.golden
+++ b/tests/compile-and-dump/Singletons/T445.golden
@@ -6,9 +6,9 @@
       where
         LitSym0KindInference :: SameKind (Apply LitSym0 arg) (LitSym1 arg) =>
                                 LitSym0 a0123456789876543210
-    type instance Apply LitSym0 a0123456789876543210 = Lit a0123456789876543210
+    type instance Apply @Natural @Nat LitSym0 a0123456789876543210 = Lit a0123456789876543210
     instance SuppressUnusedWarnings LitSym0 where
-      suppressUnusedWarnings = snd (((,) LitSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) LitSym0KindInference ())
     type LitSym1 :: Natural -> Nat
     type family LitSym1 (a0123456789876543210 :: Natural) :: Nat where
       LitSym1 a0123456789876543210 = Lit a0123456789876543210
@@ -21,35 +21,27 @@
           filterEvenGt7 :: [Nat] -> [Nat]
           filterEvenGt7 = filter (\ x -> evenb x && x > lit 7) |]
   ======>
-    type family Lambda_0123456789876543210 a_0123456789876543210 x where
-      Lambda_0123456789876543210 a_0123456789876543210 x = Apply (Apply (&&@#@$) (Apply EvenbSym0 x)) (Apply (Apply (>@#@$) x) (Apply LitSym0 (FromInteger 7)))
-    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210
-      where
-        Lambda_0123456789876543210Sym0KindInference :: SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>
-                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210
-    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210
-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where
-      suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())
-    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 x0123456789876543210
+    type family LamCases_0123456789876543210 (a_01234567898765432100123456789876543210 :: [Nat]) a_0123456789876543210 where
+      LamCases_0123456789876543210 a_0123456789876543210 x = Apply (Apply (&&@#@$) (Apply EvenbSym0 x)) (Apply (Apply (>@#@$) x) (Apply LitSym0 (FromInteger 7)))
+    data LamCases_0123456789876543210Sym0 (a_01234567898765432100123456789876543210 :: [Nat]) a_01234567898765432100123456789876543210
       where
-        Lambda_0123456789876543210Sym1KindInference :: SameKind (Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 arg) =>
-                                                       Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 x0123456789876543210
-    type instance Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) x0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210
-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())
-    type family Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210 where
-      Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (a_01234567898765432100123456789876543210 :: [Nat]) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
     type FilterEvenGt7Sym0 :: (~>) [Nat] [Nat]
     data FilterEvenGt7Sym0 :: (~>) [Nat] [Nat]
       where
         FilterEvenGt7Sym0KindInference :: SameKind (Apply FilterEvenGt7Sym0 arg) (FilterEvenGt7Sym1 arg) =>
                                           FilterEvenGt7Sym0 a0123456789876543210
-    type instance Apply FilterEvenGt7Sym0 a0123456789876543210 = FilterEvenGt7 a0123456789876543210
+    type instance Apply @[Nat] @[Nat] FilterEvenGt7Sym0 a0123456789876543210 = FilterEvenGt7 a0123456789876543210
     instance SuppressUnusedWarnings FilterEvenGt7Sym0 where
       suppressUnusedWarnings
-        = snd (((,) FilterEvenGt7Sym0KindInference) ())
+        = snd ((,) FilterEvenGt7Sym0KindInference ())
     type FilterEvenGt7Sym1 :: [Nat] -> [Nat]
     type family FilterEvenGt7Sym1 (a0123456789876543210 :: [Nat]) :: [Nat] where
       FilterEvenGt7Sym1 a0123456789876543210 = FilterEvenGt7 a0123456789876543210
@@ -58,15 +50,15 @@
       where
         EvenbSym0KindInference :: SameKind (Apply EvenbSym0 arg) (EvenbSym1 arg) =>
                                   EvenbSym0 a0123456789876543210
-    type instance Apply EvenbSym0 a0123456789876543210 = Evenb a0123456789876543210
+    type instance Apply @Nat @Bool EvenbSym0 a0123456789876543210 = Evenb a0123456789876543210
     instance SuppressUnusedWarnings EvenbSym0 where
-      suppressUnusedWarnings = snd (((,) EvenbSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) EvenbSym0KindInference ())
     type EvenbSym1 :: Nat -> Bool
     type family EvenbSym1 (a0123456789876543210 :: Nat) :: Bool where
       EvenbSym1 a0123456789876543210 = Evenb a0123456789876543210
     type FilterEvenGt7 :: [Nat] -> [Nat]
     type family FilterEvenGt7 (a :: [Nat]) :: [Nat] where
-      FilterEvenGt7 a_0123456789876543210 = Apply (Apply FilterSym0 (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210)) a_0123456789876543210
+      FilterEvenGt7 a_0123456789876543210 = Apply (Apply FilterSym0 (LamCases_0123456789876543210Sym0 a_0123456789876543210)) a_0123456789876543210
     type Evenb :: Nat -> Bool
     type family Evenb (a :: Nat) :: Bool where
       Evenb 'Zero = TrueSym0
diff --git a/tests/compile-and-dump/Singletons/T450.golden b/tests/compile-and-dump/Singletons/T450.golden
--- a/tests/compile-and-dump/Singletons/T450.golden
+++ b/tests/compile-and-dump/Singletons/T450.golden
@@ -41,9 +41,9 @@
       where
         PMkMessageSym0KindInference :: SameKind (Apply PMkMessageSym0 arg) (PMkMessageSym1 arg) =>
                                        PMkMessageSym0 a0123456789876543210
-    type instance Apply PMkMessageSym0 a0123456789876543210 = 'PMkMessage a0123456789876543210
+    type instance Apply @Symbol @PMessage PMkMessageSym0 a0123456789876543210 = 'PMkMessage a0123456789876543210
     instance SuppressUnusedWarnings PMkMessageSym0 where
-      suppressUnusedWarnings = snd (((,) PMkMessageSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) PMkMessageSym0KindInference ())
     type PMkMessageSym1 :: Symbol -> PMessage
     type family PMkMessageSym1 (a0123456789876543210 :: Symbol) :: PMessage where
       PMkMessageSym1 a0123456789876543210 = 'PMkMessage a0123456789876543210
@@ -57,14 +57,14 @@
       type Demote PMessage = Message
       fromSing (SMkMessage b) = MkMessage (fromSing b)
       toSing (MkMessage (b :: Demote Symbol))
-        = case toSing b :: SomeSing Symbol of
-            SomeSing c -> SomeSing (SMkMessage c)
+        = (\cases (SomeSing c) -> SomeSing (SMkMessage c))
+            (toSing b :: SomeSing Symbol)
     instance SingI n => SingI ('PMkMessage (n :: Symbol)) where
       sing = SMkMessage sing
     instance SingI1 'PMkMessage where
       liftSing = SMkMessage
     instance SingI (PMkMessageSym0 :: (~>) Symbol PMessage) where
-      sing = (singFun1 @PMkMessageSym0) SMkMessage
+      sing = singFun1 @PMkMessageSym0 SMkMessage
     appendMessage :: Message -> Message -> Message
     appendMessage (MkMessage (x :: Text)) (MkMessage (y :: Text))
       = MkMessage ((x <> y) :: Text)
@@ -73,19 +73,19 @@
       where
         AppendMessageSym0KindInference :: SameKind (Apply AppendMessageSym0 arg) (AppendMessageSym1 arg) =>
                                           AppendMessageSym0 a0123456789876543210
-    type instance Apply AppendMessageSym0 a0123456789876543210 = AppendMessageSym1 a0123456789876543210
+    type instance Apply @PMessage @((~>) PMessage PMessage) AppendMessageSym0 a0123456789876543210 = AppendMessageSym1 a0123456789876543210
     instance SuppressUnusedWarnings AppendMessageSym0 where
       suppressUnusedWarnings
-        = snd (((,) AppendMessageSym0KindInference) ())
+        = snd ((,) AppendMessageSym0KindInference ())
     type AppendMessageSym1 :: PMessage -> (~>) PMessage PMessage
     data AppendMessageSym1 (a0123456789876543210 :: PMessage) :: (~>) PMessage PMessage
       where
         AppendMessageSym1KindInference :: SameKind (Apply (AppendMessageSym1 a0123456789876543210) arg) (AppendMessageSym2 a0123456789876543210 arg) =>
                                           AppendMessageSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (AppendMessageSym1 a0123456789876543210) a0123456789876543210 = AppendMessage a0123456789876543210 a0123456789876543210
+    type instance Apply @PMessage @PMessage (AppendMessageSym1 a0123456789876543210) a0123456789876543210 = AppendMessage a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (AppendMessageSym1 a0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) AppendMessageSym1KindInference) ())
+        = snd ((,) AppendMessageSym1KindInference ())
     type AppendMessageSym2 :: PMessage -> PMessage -> PMessage
     type family AppendMessageSym2 (a0123456789876543210 :: PMessage) (a0123456789876543210 :: PMessage) :: PMessage where
       AppendMessageSym2 a0123456789876543210 a0123456789876543210 = AppendMessage a0123456789876543210 a0123456789876543210
@@ -93,42 +93,41 @@
     type family AppendMessage (a :: PMessage) (a :: PMessage) :: PMessage where
       AppendMessage ('PMkMessage (x :: Symbol)) ('PMkMessage (y :: Symbol)) = Apply PMkMessageSym0 (Apply (Apply (<>@#@$) x) y :: Symbol)
     sAppendMessage ::
-      forall (t :: PMessage) (t :: PMessage). Sing t
-                                              -> Sing t
-                                                 -> Sing (Apply (Apply AppendMessageSym0 t) t :: PMessage)
+      (forall (t :: PMessage) (t :: PMessage).
+       Sing t -> Sing t -> Sing (AppendMessage t t :: PMessage) :: Type)
     sAppendMessage
       (SMkMessage (sX :: Sing x))
       (SMkMessage (sY :: Sing y))
-      = case ((,) (sX :: Sing x)) (sY :: Sing y) of
-          (,) (_ :: Sing (x :: Symbol)) (_ :: Sing (y :: Symbol))
-            -> (applySing ((singFun1 @PMkMessageSym0) SMkMessage))
-                 ((applySing ((applySing ((singFun2 @(<>@#@$)) (%<>))) sX)) sY ::
-                    Sing (Apply (Apply (<>@#@$) x) y :: Symbol))
+      = (\cases
+           (_ :: Sing (x :: Symbol)) (_ :: Sing (y :: Symbol))
+             -> applySing
+                  (singFun1 @PMkMessageSym0 SMkMessage)
+                  (applySing (applySing (singFun2 @(<>@#@$) (%<>)) sX) sY ::
+                     Sing (Apply (Apply (<>@#@$) x) y :: Symbol)))
+          (sX :: Sing x) (sY :: Sing y)
     instance SingI (AppendMessageSym0 :: (~>) PMessage ((~>) PMessage PMessage)) where
-      sing = (singFun2 @AppendMessageSym0) sAppendMessage
+      sing = singFun2 @AppendMessageSym0 sAppendMessage
     instance SingI d =>
              SingI (AppendMessageSym1 (d :: PMessage) :: (~>) PMessage PMessage) where
       sing
-        = (singFun1 @(AppendMessageSym1 (d :: PMessage)))
-            (sAppendMessage (sing @d))
+        = singFun1
+            @(AppendMessageSym1 (d :: PMessage)) (sAppendMessage (sing @d))
     instance SingI1 (AppendMessageSym1 :: PMessage
                                           -> (~>) PMessage PMessage) where
       liftSing (s :: Sing (d :: PMessage))
-        = (singFun1 @(AppendMessageSym1 (d :: PMessage)))
-            (sAppendMessage s)
+        = singFun1 @(AppendMessageSym1 (d :: PMessage)) (sAppendMessage s)
     type PMkFunctionSym0 :: forall (a :: Type)
-                                   (b :: Type). (~>) ((~>) a b) (PFunction (a :: Type) (b :: Type))
-    data PMkFunctionSym0 :: (~>) ((~>) a b) (PFunction (a :: Type) (b :: Type))
+                                   (b :: Type). (~>) ((~>) a b) (PFunction a b)
+    data PMkFunctionSym0 :: (~>) ((~>) a b) (PFunction a b)
       where
         PMkFunctionSym0KindInference :: SameKind (Apply PMkFunctionSym0 arg) (PMkFunctionSym1 arg) =>
                                         PMkFunctionSym0 a0123456789876543210
-    type instance Apply PMkFunctionSym0 a0123456789876543210 = 'PMkFunction a0123456789876543210
+    type instance Apply @((~>) a b) @(PFunction a b) PMkFunctionSym0 a0123456789876543210 = 'PMkFunction a0123456789876543210
     instance SuppressUnusedWarnings PMkFunctionSym0 where
-      suppressUnusedWarnings
-        = snd (((,) PMkFunctionSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) PMkFunctionSym0KindInference ())
     type PMkFunctionSym1 :: forall (a :: Type) (b :: Type). (~>) a b
-                                                            -> PFunction (a :: Type) (b :: Type)
-    type family PMkFunctionSym1 (a0123456789876543210 :: (~>) a b) :: PFunction (a :: Type) (b :: Type) where
+                                                            -> PFunction a b
+    type family PMkFunctionSym1 @(a :: Type) @(b :: Type) (a0123456789876543210 :: (~>) a b) :: PFunction a b where
       PMkFunctionSym1 a0123456789876543210 = 'PMkFunction a0123456789876543210
     type SFunction :: forall (a :: Type) (b :: Type). PFunction a b
                                                       -> Type
@@ -136,21 +135,20 @@
                       PFunction a b -> Type
       where
         SMkFunction :: forall (a :: Type) (b :: Type) (n :: (~>) a b).
-                       (Sing n) ->
-                       SFunction ('PMkFunction n :: PFunction (a :: Type) (b :: Type))
+                       (Sing n) -> SFunction ('PMkFunction n :: PFunction a b)
     type instance Sing @(PFunction a b) = SFunction
     instance (SingKind a, SingKind b) => SingKind (PFunction a b) where
       type Demote (PFunction a b) = Function (Demote a) (Demote b)
       fromSing (SMkFunction b) = MkFunction (fromSing b)
       toSing (MkFunction (b :: Demote ((~>) a b)))
-        = case toSing b :: SomeSing ((~>) a b) of
-            SomeSing c -> SomeSing (SMkFunction c)
+        = (\cases (SomeSing c) -> SomeSing (SMkFunction c))
+            (toSing b :: SomeSing ((~>) a b))
     instance SingI n => SingI ('PMkFunction (n :: (~>) a b)) where
       sing = SMkFunction sing
     instance SingI1 'PMkFunction where
       liftSing = SMkFunction
-    instance SingI (PMkFunctionSym0 :: (~>) ((~>) a b) (PFunction (a :: Type) (b :: Type))) where
-      sing = (singFun1 @PMkFunctionSym0) SMkFunction
+    instance SingI (PMkFunctionSym0 :: (~>) ((~>) a b) (PFunction a b)) where
+      sing = singFun1 @PMkFunctionSym0 SMkFunction
     composeFunction :: Function b c -> Function a b -> Function a c
     composeFunction
       (MkFunction (f :: b -> c))
@@ -161,49 +159,52 @@
       where
         ComposeFunctionSym0KindInference :: SameKind (Apply ComposeFunctionSym0 arg) (ComposeFunctionSym1 arg) =>
                                             ComposeFunctionSym0 a0123456789876543210
-    type instance Apply ComposeFunctionSym0 a0123456789876543210 = ComposeFunctionSym1 a0123456789876543210
+    type instance Apply @(PFunction b c) @((~>) (PFunction a b) (PFunction a c)) ComposeFunctionSym0 a0123456789876543210 = ComposeFunctionSym1 a0123456789876543210
     instance SuppressUnusedWarnings ComposeFunctionSym0 where
       suppressUnusedWarnings
-        = snd (((,) ComposeFunctionSym0KindInference) ())
+        = snd ((,) ComposeFunctionSym0KindInference ())
     type ComposeFunctionSym1 :: PFunction b c
                                 -> (~>) (PFunction a b) (PFunction a c)
     data ComposeFunctionSym1 (a0123456789876543210 :: PFunction b c) :: (~>) (PFunction a b) (PFunction a c)
       where
         ComposeFunctionSym1KindInference :: SameKind (Apply (ComposeFunctionSym1 a0123456789876543210) arg) (ComposeFunctionSym2 a0123456789876543210 arg) =>
                                             ComposeFunctionSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (ComposeFunctionSym1 a0123456789876543210) a0123456789876543210 = ComposeFunction a0123456789876543210 a0123456789876543210
+    type instance Apply @(PFunction a b) @(PFunction a c) (ComposeFunctionSym1 a0123456789876543210) a0123456789876543210 = ComposeFunction a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (ComposeFunctionSym1 a0123456789876543210) where
       suppressUnusedWarnings
-        = snd (((,) ComposeFunctionSym1KindInference) ())
+        = snd ((,) ComposeFunctionSym1KindInference ())
     type ComposeFunctionSym2 :: PFunction b c
                                 -> PFunction a b -> PFunction a c
-    type family ComposeFunctionSym2 (a0123456789876543210 :: PFunction b c) (a0123456789876543210 :: PFunction a b) :: PFunction a c where
+    type family ComposeFunctionSym2 @b @c @a (a0123456789876543210 :: PFunction b c) (a0123456789876543210 :: PFunction a b) :: PFunction a c where
       ComposeFunctionSym2 a0123456789876543210 a0123456789876543210 = ComposeFunction a0123456789876543210 a0123456789876543210
     type ComposeFunction :: PFunction b c
                             -> PFunction a b -> PFunction a c
-    type family ComposeFunction (a :: PFunction b c) (a :: PFunction a b) :: PFunction a c where
+    type family ComposeFunction @b @c @a (a :: PFunction b c) (a :: PFunction a b) :: PFunction a c where
       ComposeFunction ('PMkFunction (f :: (~>) b c)) ('PMkFunction (g :: (~>) a b)) = Apply PMkFunctionSym0 (Apply (Apply (.@#@$) f) g :: (~>) a c)
     sComposeFunction ::
-      forall b c a (t :: PFunction b c) (t :: PFunction a b). Sing t
-                                                              -> Sing t
-                                                                 -> Sing (Apply (Apply ComposeFunctionSym0 t) t :: PFunction a c)
+      (forall (t :: PFunction b c) (t :: PFunction a b).
+       Sing t
+       -> Sing t -> Sing (ComposeFunction t t :: PFunction a c) :: Type)
     sComposeFunction
       (SMkFunction (sF :: Sing f))
       (SMkFunction (sG :: Sing g))
-      = case ((,) (sF :: Sing f)) (sG :: Sing g) of
-          (,) (_ :: Sing (f :: (~>) b c)) (_ :: Sing (g :: (~>) a b))
-            -> (applySing ((singFun1 @PMkFunctionSym0) SMkFunction))
-                 ((applySing ((applySing ((singFun3 @(.@#@$)) (%.))) sF)) sG ::
-                    Sing (Apply (Apply (.@#@$) f) g :: (~>) a c))
+      = (\cases
+           (_ :: Sing (f :: (~>) b c)) (_ :: Sing (g :: (~>) a b))
+             -> applySing
+                  (singFun1 @PMkFunctionSym0 SMkFunction)
+                  (applySing (applySing (singFun3 @(.@#@$) (%.)) sF) sG ::
+                     Sing (Apply (Apply (.@#@$) f) g :: (~>) a c)))
+          (sF :: Sing f) (sG :: Sing g)
     instance SingI (ComposeFunctionSym0 :: (~>) (PFunction b c) ((~>) (PFunction a b) (PFunction a c))) where
-      sing = (singFun2 @ComposeFunctionSym0) sComposeFunction
+      sing = singFun2 @ComposeFunctionSym0 sComposeFunction
     instance SingI d =>
              SingI (ComposeFunctionSym1 (d :: PFunction b c) :: (~>) (PFunction a b) (PFunction a c)) where
       sing
-        = (singFun1 @(ComposeFunctionSym1 (d :: PFunction b c)))
+        = singFun1
+            @(ComposeFunctionSym1 (d :: PFunction b c))
             (sComposeFunction (sing @d))
     instance SingI1 (ComposeFunctionSym1 :: PFunction b c
                                             -> (~>) (PFunction a b) (PFunction a c)) where
       liftSing (s :: Sing (d :: PFunction b c))
-        = (singFun1 @(ComposeFunctionSym1 (d :: PFunction b c)))
-            (sComposeFunction s)
+        = singFun1
+            @(ComposeFunctionSym1 (d :: PFunction b c)) (sComposeFunction s)
diff --git a/tests/compile-and-dump/Singletons/T470.golden b/tests/compile-and-dump/Singletons/T470.golden
--- a/tests/compile-and-dump/Singletons/T470.golden
+++ b/tests/compile-and-dump/Singletons/T470.golden
@@ -19,31 +19,31 @@
       where
         MkT1Sym0KindInference :: SameKind (Apply MkT1Sym0 arg) (MkT1Sym1 arg) =>
                                  MkT1Sym0 a0123456789876543210
-    type instance Apply MkT1Sym0 a0123456789876543210 = MkT1 a0123456789876543210
+    type instance Apply @a @(T a) MkT1Sym0 a0123456789876543210 = MkT1 a0123456789876543210
     instance SuppressUnusedWarnings MkT1Sym0 where
-      suppressUnusedWarnings = snd (((,) MkT1Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkT1Sym0KindInference ())
     type MkT1Sym1 :: a -> T a
-    type family MkT1Sym1 (a0123456789876543210 :: a) :: T a where
+    type family MkT1Sym1 @a (a0123456789876543210 :: a) :: T a where
       MkT1Sym1 a0123456789876543210 = MkT1 a0123456789876543210
     type MkT2Sym0 :: (~>) Void (T a)
     data MkT2Sym0 :: (~>) Void (T a)
       where
         MkT2Sym0KindInference :: SameKind (Apply MkT2Sym0 arg) (MkT2Sym1 arg) =>
                                  MkT2Sym0 a0123456789876543210
-    type instance Apply MkT2Sym0 a0123456789876543210 = MkT2 a0123456789876543210
+    type instance Apply @Void @(T a) MkT2Sym0 a0123456789876543210 = MkT2 a0123456789876543210
     instance SuppressUnusedWarnings MkT2Sym0 where
-      suppressUnusedWarnings = snd (((,) MkT2Sym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkT2Sym0KindInference ())
     type MkT2Sym1 :: Void -> T a
-    type family MkT2Sym1 (a0123456789876543210 :: Void) :: T a where
+    type family MkT2Sym1 @a (a0123456789876543210 :: Void) :: T a where
       MkT2Sym1 a0123456789876543210 = MkT2 a0123456789876543210
     type MkSSym0 :: (~>) Bool S
     data MkSSym0 :: (~>) Bool S
       where
         MkSSym0KindInference :: SameKind (Apply MkSSym0 arg) (MkSSym1 arg) =>
                                 MkSSym0 a0123456789876543210
-    type instance Apply MkSSym0 a0123456789876543210 = MkS a0123456789876543210
+    type instance Apply @Bool @S MkSSym0 a0123456789876543210 = MkS a0123456789876543210
     instance SuppressUnusedWarnings MkSSym0 where
-      suppressUnusedWarnings = snd (((,) MkSSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) MkSSym0KindInference ())
     type MkSSym1 :: Bool -> S
     type family MkSSym1 (a0123456789876543210 :: Bool) :: S where
       MkSSym1 a0123456789876543210 = MkS a0123456789876543210
@@ -58,10 +58,11 @@
       fromSing (SMkT1 b) = MkT1 (fromSing b)
       fromSing (SMkT2 b) = MkT2 (fromSing b)
       toSing (MkT1 (b :: Demote a))
-        = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SMkT1 c)
+        = (\cases (SomeSing c) -> SomeSing (SMkT1 c))
+            (toSing b :: SomeSing a)
       toSing (MkT2 (b :: Demote Void))
-        = case toSing b :: SomeSing Void of
-            SomeSing c -> SomeSing (SMkT2 c)
+        = (\cases (SomeSing c) -> SomeSing (SMkT2 c))
+            (toSing b :: SomeSing Void)
     data SS :: S -> Type
       where SMkS :: forall (n :: Bool). !(Sing n) -> SS (MkS n :: S)
     type instance Sing @S = SS
@@ -69,28 +70,29 @@
       type Demote S = S
       fromSing (SMkS b) = MkS (fromSing b)
       toSing (MkS (b :: Demote Bool))
-        = case toSing b :: SomeSing Bool of SomeSing c -> SomeSing (SMkS c)
+        = (\cases (SomeSing c) -> SomeSing (SMkS c))
+            (toSing b :: SomeSing Bool)
     instance SingI n => SingI (MkT1 (n :: a)) where
       sing = SMkT1 sing
     instance SingI1 MkT1 where
       liftSing = SMkT1
     instance SingI (MkT1Sym0 :: (~>) a (T a)) where
-      sing = (singFun1 @MkT1Sym0) SMkT1
+      sing = singFun1 @MkT1Sym0 SMkT1
     instance SingI n => SingI (MkT2 (n :: Void)) where
       sing = SMkT2 sing
     instance SingI1 MkT2 where
       liftSing = SMkT2
     instance SingI (MkT2Sym0 :: (~>) Void (T a)) where
-      sing = (singFun1 @MkT2Sym0) SMkT2
+      sing = singFun1 @MkT2Sym0 SMkT2
     instance SingI n => SingI (MkS (n :: Bool)) where
       sing = SMkS sing
     instance SingI1 MkS where
       liftSing = SMkS
     instance SingI (MkSSym0 :: (~>) Bool S) where
-      sing = (singFun1 @MkSSym0) SMkS
-
-Singletons/T470.hs:0:0: warning:
+      sing = singFun1 @MkSSym0 SMkS
+Singletons/T470.hs:0:0: warning: [GHC-39584]
     {-# UNPACK #-} pragmas are ignored by `singletons-th`.
   |
 6 | $(singletons [d|
   |  ^^^^^^^^^^^^^^^...
+
diff --git a/tests/compile-and-dump/Singletons/T480.golden b/tests/compile-and-dump/Singletons/T480.golden
--- a/tests/compile-and-dump/Singletons/T480.golden
+++ b/tests/compile-and-dump/Singletons/T480.golden
@@ -1,10 +1,10 @@
 
-Singletons/T480.hs:0:0: error: Q monad failure
+Singletons/T480.hs:0:0: error: [GHC-39584] Q monad failure
   |
 5 | $(singletons
   |  ^^^^^^^^^^^...
 
-Singletons/T480.hs:0:0: error:
+Singletons/T480.hs:0:0: error: [GHC-39584]
     `singletons-th` does not support wildcard types
 	unless they appear in visible type patterns of data constructors
 	In the type: _
diff --git a/tests/compile-and-dump/Singletons/T487.golden b/tests/compile-and-dump/Singletons/T487.golden
--- a/tests/compile-and-dump/Singletons/T487.golden
+++ b/tests/compile-and-dump/Singletons/T487.golden
@@ -25,9 +25,9 @@
       where
         ConsExSym0KindInference :: SameKind (Apply ConsExSym0 arg) (ConsExSym1 arg) =>
                                    ConsExSym0 a0123456789876543210
-    type instance Apply ConsExSym0 a0123456789876543210 = ConsEx a0123456789876543210
+    type instance Apply @Char @Symbol ConsExSym0 a0123456789876543210 = ConsEx a0123456789876543210
     instance SuppressUnusedWarnings ConsExSym0 where
-      suppressUnusedWarnings = snd (((,) ConsExSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) ConsExSym0KindInference ())
     type ConsExSym1 :: Char -> Symbol
     type family ConsExSym1 (a0123456789876543210 :: Char) :: Symbol where
       ConsExSym1 a0123456789876543210 = ConsEx a0123456789876543210
@@ -49,25 +49,25 @@
     type ExprEx :: Char
     type family ExprEx :: Char where
       ExprEx = 'a'
-    sCharToNatEx :: Sing (CharToNatExSym0 :: Natural)
-    sNatToCharEx :: Sing (NatToCharExSym0 :: Char)
-    sUnconsEx :: Sing (UnconsExSym0 :: Maybe (Char, Symbol))
+    sCharToNatEx :: (Sing (CharToNatEx :: Natural) :: Type)
+    sNatToCharEx :: (Sing (NatToCharEx :: Char) :: Type)
+    sUnconsEx :: (Sing (UnconsEx :: Maybe (Char, Symbol)) :: Type)
     sConsEx ::
-      forall (t :: Char). Sing t -> Sing (Apply ConsExSym0 t :: Symbol)
-    sExprEx :: Sing (ExprExSym0 :: Char)
+      (forall (t :: Char). Sing t -> Sing (ConsEx t :: Symbol) :: Type)
+    sExprEx :: (Sing (ExprEx :: Char) :: Type)
     sCharToNatEx
-      = (applySing ((singFun1 @CharToNatSym0) sCharToNat))
-          (sing :: Sing 'a')
+      = applySing (singFun1 @CharToNatSym0 sCharToNat) (sing :: Sing 'a')
     sNatToCharEx
-      = (applySing ((singFun1 @NatToCharSym0) sNatToChar))
+      = applySing
+          (singFun1 @NatToCharSym0 sNatToChar)
           (sFromInteger (sing :: Sing 97))
     sUnconsEx
-      = (applySing ((singFun1 @UnconsSymbolSym0) sUnconsSymbol))
-          (sing :: Sing "abc")
+      = applySing
+          (singFun1 @UnconsSymbolSym0 sUnconsSymbol) (sing :: Sing "abc")
     sConsEx (sX :: Sing x)
-      = (applySing
-           ((applySing ((singFun2 @ConsSymbolSym0) sConsSymbol)) sX))
+      = applySing
+          (applySing (singFun2 @ConsSymbolSym0 sConsSymbol) sX)
           (sing :: Sing "bc")
     sExprEx = sing :: Sing 'a'
     instance SingI (ConsExSym0 :: (~>) Char Symbol) where
-      sing = (singFun1 @ConsExSym0) sConsEx
+      sing = singFun1 @ConsExSym0 sConsEx
diff --git a/tests/compile-and-dump/Singletons/T489.golden b/tests/compile-and-dump/Singletons/T489.golden
--- a/tests/compile-and-dump/Singletons/T489.golden
+++ b/tests/compile-and-dump/Singletons/T489.golden
@@ -18,9 +18,9 @@
       where
         FlurmpSym0KindInference :: SameKind (Apply FlurmpSym0 arg) (FlurmpSym1 arg) =>
                                    FlurmpSym0 a0123456789876543210
-    type instance Apply FlurmpSym0 a0123456789876543210 = Flurmp a0123456789876543210
+    type instance Apply @(Maybe ()) @() FlurmpSym0 a0123456789876543210 = Flurmp a0123456789876543210
     instance SuppressUnusedWarnings FlurmpSym0 where
-      suppressUnusedWarnings = snd (((,) FlurmpSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FlurmpSym0KindInference ())
     type FlurmpSym1 :: Maybe () -> ()
     type family FlurmpSym1 (a0123456789876543210 :: Maybe ()) :: () where
       FlurmpSym1 a0123456789876543210 = Flurmp a0123456789876543210
@@ -29,32 +29,31 @@
       where
         BlahSym0KindInference :: SameKind (Apply BlahSym0 arg) (BlahSym1 arg) =>
                                  BlahSym0 a0123456789876543210
-    type instance Apply BlahSym0 a0123456789876543210 = Blah a0123456789876543210
+    type instance Apply @(Maybe a) @[a] BlahSym0 a0123456789876543210 = Blah a0123456789876543210
     instance SuppressUnusedWarnings BlahSym0 where
-      suppressUnusedWarnings = snd (((,) BlahSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BlahSym0KindInference ())
     type BlahSym1 :: Maybe a -> [a]
-    type family BlahSym1 (a0123456789876543210 :: Maybe a) :: [a] where
+    type family BlahSym1 @a (a0123456789876543210 :: Maybe a) :: [a] where
       BlahSym1 a0123456789876543210 = Blah a0123456789876543210
     type Flurmp :: Maybe () -> ()
     type family Flurmp (a :: Maybe ()) :: () where
       Flurmp ('Nothing @_) = Tuple0Sym0
       Flurmp ('Just '()) = Tuple0Sym0
     type Blah :: Maybe a -> [a]
-    type family Blah (a :: Maybe a) :: [a] where
+    type family Blah @a (a :: Maybe a) :: [a] where
       Blah ('Just @a x) = Apply (Apply (:@#@$) (x :: a)) NilSym0
       Blah ('Nothing @a) = NilSym0 :: [a]
     sFlurmp ::
-      forall (t :: Maybe ()). Sing t -> Sing (Apply FlurmpSym0 t :: ())
+      (forall (t :: Maybe ()). Sing t -> Sing (Flurmp t :: ()) :: Type)
     sBlah ::
-      forall a (t :: Maybe a). Sing t -> Sing (Apply BlahSym0 t :: [a])
+      (forall (t :: Maybe a). Sing t -> Sing (Blah t :: [a]) :: Type)
     sFlurmp (SNothing @_) = STuple0
     sFlurmp (SJust STuple0) = STuple0
     sBlah (SJust @a (sX :: Sing x))
-      = (applySing
-           ((applySing ((singFun2 @(:@#@$)) SCons)) (sX :: Sing (x :: a))))
-          SNil
+      = applySing
+          (applySing (singFun2 @(:@#@$) SCons) (sX :: Sing (x :: a))) SNil
     sBlah (SNothing @a) = SNil :: Sing (NilSym0 :: [a])
     instance SingI (FlurmpSym0 :: (~>) (Maybe ()) ()) where
-      sing = (singFun1 @FlurmpSym0) sFlurmp
+      sing = singFun1 @FlurmpSym0 sFlurmp
     instance SingI (BlahSym0 :: (~>) (Maybe a) [a]) where
-      sing = (singFun1 @BlahSym0) sBlah
+      sing = singFun1 @BlahSym0 sBlah
diff --git a/tests/compile-and-dump/Singletons/T511.golden b/tests/compile-and-dump/Singletons/T511.golden
--- a/tests/compile-and-dump/Singletons/T511.golden
+++ b/tests/compile-and-dump/Singletons/T511.golden
@@ -1,13 +1,13 @@
-
-Singletons/T511.hs:0:0: error: Q monad failure
+Singletons/T511.hs:0:0: error: [GHC-39584] Q monad failure
   |
 7 | $(singletons [d|
   |  ^^^^^^^^^^^^^^^...
 
-Singletons/T511.hs:0:0: error:
+Singletons/T511.hs:0:0: error: [GHC-39584]
     `singletons-th` does not support partial applications of (->)
-	In the type: Data.Proxy.Proxy (->)
+	In the type: GHC.Internal.Data.Proxy.Proxy (->)
 
   |
 7 | $(singletons [d|
   |  ^^^^^^^^^^^^^^^...
+
diff --git a/tests/compile-and-dump/Singletons/T536.golden b/tests/compile-and-dump/Singletons/T536.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T536.golden
@@ -0,0 +1,101 @@
+Singletons/T536.hs:(0,0)-(0,0): Splicing declarations
+    let
+      customPromote :: Name -> Name
+      customPromote n
+        | n == ''Message = ''PMessage
+        | n == 'MkMessage = 'PMkMessage
+        | n == ''Text = ''Symbol
+        | otherwise = promotedDataTypeOrConName defaultOptions n
+      customDefun :: Name -> Int -> Name
+      customDefun n sat
+        = defunctionalizedName defaultOptions (customPromote n) sat
+    in
+      withOptions
+        defaultOptions
+          {promotedDataTypeOrConName = customPromote,
+           defunctionalizedName = customDefun}
+        $ do decs1 <- genSingletons [''Message]
+             decs2 <- singletons
+                        [d| hello :: Message
+                            hello = MkMessage "hello" |]
+             decs3 <- singDecideInstances [''Message]
+             decs4 <- showSingInstances [''Message]
+             return $ decs1 ++ decs2 ++ decs3 ++ decs4
+  ======>
+    type PMkMessageSym0 :: (Data.Singletons.~>) Symbol PMessage
+    data PMkMessageSym0 :: (Data.Singletons.~>) Symbol PMessage
+      where
+        PMkMessageSym0KindInference :: Data.Singletons.SameKind (Data.Singletons.Apply PMkMessageSym0 arg) (PMkMessageSym1 arg) =>
+                                       PMkMessageSym0 a0123456789876543210
+    type instance Data.Singletons.Apply @Symbol @PMessage PMkMessageSym0 a0123456789876543210 = 'PMkMessage a0123456789876543210
+    instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings PMkMessageSym0 where
+      Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings
+        = snd ((,) PMkMessageSym0KindInference ())
+    type PMkMessageSym1 :: Symbol -> PMessage
+    type family PMkMessageSym1 (a0123456789876543210 :: Symbol) :: PMessage where
+      PMkMessageSym1 a0123456789876543210 = 'PMkMessage a0123456789876543210
+    type SMessage :: PMessage -> Type
+    data SMessage :: PMessage -> Type
+      where
+        SMkMessage :: forall (n :: Symbol).
+                      (Data.Singletons.Sing n) -> SMessage ('PMkMessage n :: PMessage)
+    type instance Data.Singletons.Sing @PMessage = SMessage
+    instance Data.Singletons.SingKind PMessage where
+      type Data.Singletons.Demote PMessage = Message
+      Data.Singletons.fromSing (SMkMessage b)
+        = MkMessage (Data.Singletons.fromSing b)
+      Data.Singletons.toSing
+        (MkMessage (b :: Data.Singletons.Demote Symbol))
+        = (\cases
+             (Data.Singletons.SomeSing c)
+               -> Data.Singletons.SomeSing (SMkMessage c))
+            (Data.Singletons.toSing b :: Data.Singletons.SomeSing Symbol)
+    instance Data.Singletons.SingI n =>
+             Data.Singletons.SingI ('PMkMessage (n :: Symbol)) where
+      Data.Singletons.sing = SMkMessage Data.Singletons.sing
+    instance Data.Singletons.SingI1 'PMkMessage where
+      Data.Singletons.liftSing = SMkMessage
+    instance Data.Singletons.SingI (PMkMessageSym0 :: (Data.Singletons.~>) Symbol PMessage) where
+      Data.Singletons.sing
+        = Data.Singletons.singFun1 @PMkMessageSym0 SMkMessage
+    hello :: Message
+    hello = MkMessage "hello"
+    type HelloSym0 :: PMessage
+    type family HelloSym0 :: PMessage where
+      HelloSym0 = Hello
+    type Hello :: PMessage
+    type family Hello :: PMessage where
+      Hello = Data.Singletons.Apply PMkMessageSym0 (FromString "hello")
+    sHello :: (Data.Singletons.Sing (Hello :: PMessage) :: Type)
+    sHello
+      = Data.Singletons.applySing
+          (Data.Singletons.singFun1 @PMkMessageSym0 SMkMessage)
+          (sFromString
+             (Data.Singletons.sing :: Data.Singletons.Sing "hello"))
+    instance Data.Singletons.Decide.SDecide Text =>
+             Data.Singletons.Decide.SDecide PMessage where
+      (Data.Singletons.Decide.%~) (SMkMessage a) (SMkMessage b)
+        = (\cases
+             (Data.Singletons.Decide.Proved GHC.Internal.Data.Type.Equality.Refl)
+               -> Data.Singletons.Decide.Proved
+                    GHC.Internal.Data.Type.Equality.Refl
+             (Data.Singletons.Decide.Disproved contra)
+               -> Data.Singletons.Decide.Disproved
+                    (\cases
+                       GHC.Internal.Data.Type.Equality.Refl
+                         -> contra GHC.Internal.Data.Type.Equality.Refl))
+            ((Data.Singletons.Decide.%~) a b)
+    instance Eq (SMessage (z :: PMessage)) where
+      (==) _ _ = True
+    instance Data.Singletons.Decide.SDecide Text =>
+             GHC.Internal.Data.Type.Equality.TestEquality (SMessage :: PMessage
+                                                                       -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
+        = Data.Singletons.Decide.decideEquality
+    instance Data.Singletons.Decide.SDecide Text =>
+             GHC.Internal.Data.Type.Coercion.TestCoercion (SMessage :: PMessage
+                                                                       -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
+        = Data.Singletons.Decide.decideCoercion
+    deriving instance Data.Singletons.ShowSing.ShowSing Text =>
+                      Show (SMessage (z :: PMessage))
diff --git a/tests/compile-and-dump/Singletons/T536.hs b/tests/compile-and-dump/Singletons/T536.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T536.hs
@@ -0,0 +1,41 @@
+{-# LANGUAGE OverloadedStrings #-}
+module T536 where
+
+import           Data.Singletons.TH         (genSingletons, showSingInstances,
+                                             singDecideInstances, singletons)
+import           Data.Singletons.TH.Options (defaultOptions,
+                                             defunctionalizedName,
+                                             promotedDataTypeOrConName,
+                                             withOptions)
+import           Data.String                (fromString)
+import           Data.String.Singletons     (FromString, sFromString)
+import           Data.Text                  (Text)
+import           GHC.TypeLits.Singletons    (Symbol)
+import           Language.Haskell.TH        (Name)
+
+-- Term-level
+newtype Message = MkMessage Text
+-- Type-level
+newtype PMessage = PMkMessage Symbol
+
+$(let customPromote :: Name -> Name
+      customPromote n
+        | n == ''Message  = ''PMessage
+        | n == 'MkMessage = 'PMkMessage
+        | n == ''Text     = ''Symbol
+        | otherwise       = promotedDataTypeOrConName defaultOptions n
+
+      customDefun :: Name -> Int -> Name
+      customDefun n sat = defunctionalizedName defaultOptions (customPromote n) sat in
+
+  withOptions defaultOptions{ promotedDataTypeOrConName = customPromote
+                            , defunctionalizedName      = customDefun
+                            } $ do
+    decs1 <- genSingletons [''Message]
+    decs2 <- singletons [d|
+               hello :: Message
+               hello = MkMessage "hello"
+               |]
+    decs3 <- singDecideInstances [''Message]
+    decs4 <- showSingInstances [''Message]
+    return $ decs1 ++ decs2 ++ decs3 ++ decs4)
diff --git a/tests/compile-and-dump/Singletons/T54.golden b/tests/compile-and-dump/Singletons/T54.golden
--- a/tests/compile-and-dump/Singletons/T54.golden
+++ b/tests/compile-and-dump/Singletons/T54.golden
@@ -5,53 +5,42 @@
   ======>
     g :: Bool -> Bool
     g e = (case [not] of [_] -> not) e
-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 e0123456789876543210
+    type family LamCases_0123456789876543210 (e0123456789876543210 :: Bool) a_0123456789876543210 where
+      LamCases_0123456789876543210 e '[_] = NotSym0
+    data LamCases_0123456789876543210Sym0 (e0123456789876543210 :: Bool) a_01234567898765432100123456789876543210
       where
-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>
-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 e0123456789876543210
-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 e0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 e0123456789876543210
-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 e0123456789876543210) arg) (LamCases_0123456789876543210Sym1 e0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 e0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 e0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 e0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 e0123456789876543210) where
       suppressUnusedWarnings
-        = snd
-            (((,)
-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)
-               ())
-    type family Let0123456789876543210Scrutinee_0123456789876543210Sym1 e0123456789876543210 where
-      Let0123456789876543210Scrutinee_0123456789876543210Sym1 e0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 e0123456789876543210
-    type family Let0123456789876543210Scrutinee_0123456789876543210 e where
-      Let0123456789876543210Scrutinee_0123456789876543210 e = Apply (Apply (:@#@$) NotSym0) NilSym0
-    type family Case_0123456789876543210 e t where
-      Case_0123456789876543210 e '[_] = NotSym0
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (e0123456789876543210 :: Bool) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 e0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 e0123456789876543210 a_01234567898765432100123456789876543210
     type GSym0 :: (~>) Bool Bool
     data GSym0 :: (~>) Bool Bool
       where
         GSym0KindInference :: SameKind (Apply GSym0 arg) (GSym1 arg) =>
                               GSym0 a0123456789876543210
-    type instance Apply GSym0 a0123456789876543210 = G a0123456789876543210
+    type instance Apply @Bool @Bool GSym0 a0123456789876543210 = G a0123456789876543210
     instance SuppressUnusedWarnings GSym0 where
-      suppressUnusedWarnings = snd (((,) GSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) GSym0KindInference ())
     type GSym1 :: Bool -> Bool
     type family GSym1 (a0123456789876543210 :: Bool) :: Bool where
       GSym1 a0123456789876543210 = G a0123456789876543210
     type G :: Bool -> Bool
     type family G (a :: Bool) :: Bool where
-      G e = Apply (Case_0123456789876543210 e (Let0123456789876543210Scrutinee_0123456789876543210Sym1 e)) e
-    sG :: forall (t :: Bool). Sing t -> Sing (Apply GSym0 t :: Bool)
+      G e = Apply (Apply (LamCases_0123456789876543210Sym0 e) (Apply (Apply (:@#@$) NotSym0) NilSym0)) e
+    sG :: (forall (t :: Bool). Sing t -> Sing (G t :: Bool) :: Type)
     sG (sE :: Sing e)
-      = (applySing
-           (let
-              sScrutinee_0123456789876543210 ::
-                Sing @_ (Let0123456789876543210Scrutinee_0123456789876543210Sym1 e)
-              sScrutinee_0123456789876543210
-                = (applySing
-                     ((applySing ((singFun2 @(:@#@$)) SCons))
-                        ((singFun1 @NotSym0) sNot)))
-                    SNil
-            in
-              (id
-                 @(Sing (Case_0123456789876543210 e (Let0123456789876543210Scrutinee_0123456789876543210Sym1 e))))
-                (case sScrutinee_0123456789876543210 of
-                   SCons _ SNil -> (singFun1 @NotSym0) sNot)))
+      = applySing
+          (applySing
+             (singFun1
+                @(LamCases_0123456789876543210Sym0 e)
+                (\cases (SCons _ SNil) -> singFun1 @NotSym0 sNot))
+             (applySing
+                (applySing (singFun2 @(:@#@$) SCons) (singFun1 @NotSym0 sNot))
+                SNil))
           sE
     instance SingI (GSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @GSym0) sG
+      sing = singFun1 @GSym0 sG
diff --git a/tests/compile-and-dump/Singletons/T555.golden b/tests/compile-and-dump/Singletons/T555.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T555.golden
@@ -0,0 +1,110 @@
+Singletons/T555.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| data MyPropKind
+            = Location | Quaternion
+            deriving (Eq, Ord, Show) |]
+  ======>
+    data MyPropKind
+      = Location | Quaternion
+      deriving (Eq, Ord, Show)
+    type LocationSym0 :: MyPropKind
+    type family LocationSym0 :: MyPropKind where
+      LocationSym0 = Location
+    type QuaternionSym0 :: MyPropKind
+    type family QuaternionSym0 :: MyPropKind where
+      QuaternionSym0 = Quaternion
+    type TFHelper_0123456789876543210 :: MyPropKind
+                                         -> MyPropKind -> Bool
+    type family TFHelper_0123456789876543210 (a :: MyPropKind) (a :: MyPropKind) :: Bool where
+      TFHelper_0123456789876543210 Location Location = TrueSym0
+      TFHelper_0123456789876543210 Location Quaternion = FalseSym0
+      TFHelper_0123456789876543210 Quaternion Location = FalseSym0
+      TFHelper_0123456789876543210 Quaternion Quaternion = TrueSym0
+    instance PEq MyPropKind where
+      type (==) a a = TFHelper_0123456789876543210 a a
+    type Compare_0123456789876543210 :: MyPropKind
+                                        -> MyPropKind -> Ordering
+    type family Compare_0123456789876543210 (a :: MyPropKind) (a :: MyPropKind) :: Ordering where
+      Compare_0123456789876543210 Location Location = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
+      Compare_0123456789876543210 Quaternion Quaternion = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0
+      Compare_0123456789876543210 Location Quaternion = LTSym0
+      Compare_0123456789876543210 Quaternion Location = GTSym0
+    instance POrd MyPropKind where
+      type Compare a a = Compare_0123456789876543210 a a
+    type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                          -> MyPropKind -> Symbol -> Symbol
+    type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: MyPropKind) (a :: Symbol) :: Symbol where
+      ShowsPrec_0123456789876543210 _ Location a_0123456789876543210 = Apply (Apply ShowStringSym0 "Location") a_0123456789876543210
+      ShowsPrec_0123456789876543210 _ Quaternion a_0123456789876543210 = Apply (Apply ShowStringSym0 "Quaternion") a_0123456789876543210
+    instance PShow MyPropKind where
+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a
+    data SMyPropKind :: MyPropKind -> Type
+      where
+        SLocation :: SMyPropKind (Location :: MyPropKind)
+        SQuaternion :: SMyPropKind (Quaternion :: MyPropKind)
+    type instance Sing @MyPropKind = SMyPropKind
+    instance SingKind MyPropKind where
+      type Demote MyPropKind = MyPropKind
+      fromSing SLocation = Location
+      fromSing SQuaternion = Quaternion
+      toSing Location = SomeSing SLocation
+      toSing Quaternion = SomeSing SQuaternion
+    instance SEq MyPropKind where
+      (%==) SLocation SLocation = STrue
+      (%==) SLocation SQuaternion = SFalse
+      (%==) SQuaternion SLocation = SFalse
+      (%==) SQuaternion SQuaternion = STrue
+    instance SOrd MyPropKind where
+      sCompare SLocation SLocation
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            SNil
+      sCompare SQuaternion SQuaternion
+        = applySing
+            (applySing
+               (applySing (singFun3 @FoldlSym0 sFoldl) (singFun2 @(<>@#@$) (%<>)))
+               SEQ)
+            SNil
+      sCompare SLocation SQuaternion = SLT
+      sCompare SQuaternion SLocation = SGT
+    instance SShow MyPropKind where
+      sShowsPrec
+        _
+        SLocation
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Location"))
+            sA_0123456789876543210
+      sShowsPrec
+        _
+        SQuaternion
+        (sA_0123456789876543210 :: Sing a_0123456789876543210)
+        = applySing
+            (applySing
+               (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "Quaternion"))
+            sA_0123456789876543210
+    instance SDecide MyPropKind where
+      (%~) SLocation SLocation = Proved Refl
+      (%~) SLocation SQuaternion = Disproved (\case)
+      (%~) SQuaternion SLocation = Disproved (\case)
+      (%~) SQuaternion SQuaternion = Proved Refl
+    instance Eq (SMyPropKind (z :: MyPropKind)) where
+      (==) _ _ = True
+    instance GHC.Internal.Data.Type.Equality.TestEquality (SMyPropKind :: MyPropKind
+                                                                          -> Type) where
+      GHC.Internal.Data.Type.Equality.testEquality
+        = Data.Singletons.Decide.decideEquality
+    instance GHC.Internal.Data.Type.Coercion.TestCoercion (SMyPropKind :: MyPropKind
+                                                                          -> Type) where
+      GHC.Internal.Data.Type.Coercion.testCoercion
+        = Data.Singletons.Decide.decideCoercion
+    instance Ord (SMyPropKind (z :: MyPropKind)) where
+      compare _ _ = EQ
+    deriving instance Show (SMyPropKind (z :: MyPropKind))
+    instance SingI Location where
+      sing = SLocation
+    instance SingI Quaternion where
+      sing = SQuaternion
diff --git a/tests/compile-and-dump/Singletons/T555.hs b/tests/compile-and-dump/Singletons/T555.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T555.hs
@@ -0,0 +1,15 @@
+module T555 where
+
+-- NB: /not/ importing Data.Singletons.Base.TH below, but rather the more
+-- restricted Data.Singletons.TH that does not re-export anything from
+-- singletons-base. We want to ensure that this code works with only a simple
+-- Prelude.Singletons import if possible.
+import Data.Singletons.TH
+import Prelude.Singletons
+
+$(singletons [d|
+  data MyPropKind = Location
+                  | Quaternion
+
+      deriving(Eq,Ord,Show)
+  |])
diff --git a/tests/compile-and-dump/Singletons/T559.golden b/tests/compile-and-dump/Singletons/T559.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T559.golden
@@ -0,0 +1,11 @@
+Singletons/T559.hs:0:0:: Splicing declarations
+    singletons [d| type data T = MkT |]
+  ======>
+    type data T = MkT
+    type MkTSym0 :: T
+    type family MkTSym0 :: T where
+      MkTSym0 = MkT
+    data ST :: T -> Type where SMkT :: ST (MkT :: T)
+    type instance Sing @T = ST
+    instance SingI MkT where
+      sing = SMkT
diff --git a/tests/compile-and-dump/Singletons/T559.hs b/tests/compile-and-dump/Singletons/T559.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T559.hs
@@ -0,0 +1,6 @@
+{-# LANGUAGE TypeData #-}
+module T559 where
+
+import Data.Singletons.TH
+
+$(singletons [d| type data T = MkT |])
diff --git a/tests/compile-and-dump/Singletons/T563.golden b/tests/compile-and-dump/Singletons/T563.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T563.golden
@@ -0,0 +1,70 @@
+Singletons/T563.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| infixr 6 `unFoo`
+          
+          data Foo = MkFoo {unFoo :: Bool} |]
+  ======>
+    infixr 6 `unFoo`
+    data Foo = MkFoo {unFoo :: Bool}
+    type MkFooSym0 :: (~>) Bool Foo
+    data MkFooSym0 :: (~>) Bool Foo
+      where
+        MkFooSym0KindInference :: SameKind (Apply MkFooSym0 arg) (MkFooSym1 arg) =>
+                                  MkFooSym0 a0123456789876543210
+    type instance Apply @Bool @Foo MkFooSym0 a0123456789876543210 = MkFoo a0123456789876543210
+    instance SuppressUnusedWarnings MkFooSym0 where
+      suppressUnusedWarnings = snd ((,) MkFooSym0KindInference ())
+    type MkFooSym1 :: Bool -> Foo
+    type family MkFooSym1 (a0123456789876543210 :: Bool) :: Foo where
+      MkFooSym1 a0123456789876543210 = MkFoo a0123456789876543210
+    data SFoo :: Foo -> Type
+      where
+        SMkFoo :: forall (n :: Bool). (Sing n) -> SFoo (MkFoo n :: Foo)
+    type instance Sing @Foo = SFoo
+    instance SingKind Foo where
+      type Demote Foo = Foo
+      fromSing (SMkFoo b) = MkFoo (fromSing b)
+      toSing (MkFoo (b :: Demote Bool))
+        = (\cases (SomeSing c) -> SomeSing (SMkFoo c))
+            (toSing b :: SomeSing Bool)
+    instance SingI n => SingI (MkFoo (n :: Bool)) where
+      sing = SMkFoo sing
+    instance SingI1 MkFoo where
+      liftSing = SMkFoo
+    instance SingI (MkFooSym0 :: (~>) Bool Foo) where
+      sing = singFun1 @MkFooSym0 SMkFoo
+Singletons/T563.hs:(0,0)-(0,0): Splicing declarations
+    singletonsOnly
+      [d| unFoo' :: Foo -> Bool
+          unFoo' = unFoo |]
+  ======>
+    type UnFoo'Sym0 :: (~>) Foo Bool
+    data UnFoo'Sym0 :: (~>) Foo Bool
+      where
+        UnFoo'Sym0KindInference :: SameKind (Apply UnFoo'Sym0 arg) (UnFoo'Sym1 arg) =>
+                                   UnFoo'Sym0 a0123456789876543210
+    type instance Apply @Foo @Bool UnFoo'Sym0 a0123456789876543210 = UnFoo' a0123456789876543210
+    instance SuppressUnusedWarnings UnFoo'Sym0 where
+      suppressUnusedWarnings = snd ((,) UnFoo'Sym0KindInference ())
+    type UnFoo'Sym1 :: Foo -> Bool
+    type family UnFoo'Sym1 (a0123456789876543210 :: Foo) :: Bool where
+      UnFoo'Sym1 a0123456789876543210 = UnFoo' a0123456789876543210
+    type UnFoo' :: Foo -> Bool
+    type family UnFoo' (a :: Foo) :: Bool where
+      UnFoo' a_0123456789876543210 = Apply UnFooSym0 a_0123456789876543210
+    sUnFoo' ::
+      (forall (t :: Foo). Sing t -> Sing (UnFoo' t :: Bool) :: Type)
+    sUnFoo' (sA_0123456789876543210 :: Sing a_0123456789876543210)
+      = applySing sUnFoo sA_0123456789876543210
+    instance SingI (UnFoo'Sym0 :: (~>) Foo Bool) where
+      sing = singFun1 @UnFoo'Sym0 sUnFoo'
+Singletons/T563.hs:0:0: error: [GHC-76037]
+    Not in scope: type constructor or class ‘UnFooSym0’
+    Suggested fix:
+      Perhaps use one of these:
+        ‘UnFoo'Sym0’ (line 13), ‘MkFooSym0’ (line 7),
+        ‘UnFoo'Sym1’ (line 13)
+   |
+13 | $(singletonsOnly [d|
+   |  ^^^^^^^^^^^^^^^^^^^...
+
diff --git a/tests/compile-and-dump/Singletons/T563.hs b/tests/compile-and-dump/Singletons/T563.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T563.hs
@@ -0,0 +1,16 @@
+{-# LANGUAGE NoFieldSelectors #-}
+module T563 where
+
+import Data.Singletons.Base.TH
+import Prelude.Singletons
+
+$(singletons [d|
+  infixr 6 `unFoo`
+  data Foo = MkFoo { unFoo :: Bool }
+  |])
+
+-- This should not compile:
+$(singletonsOnly [d|
+  unFoo' :: Foo -> Bool
+  unFoo' = unFoo
+  |])
diff --git a/tests/compile-and-dump/Singletons/T565.golden b/tests/compile-and-dump/Singletons/T565.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T565.golden
@@ -0,0 +1,16 @@
+Singletons/T565.hs:(0,0)-(0,0): Splicing declarations
+    singletons [d| data C a where D :: forall {a}. C a |]
+  ======>
+    data C a where D :: forall {a}. C a
+    type DSym0 :: forall {a}. C a
+    type family DSym0 :: C a where
+      DSym0 = D
+    data SC :: forall a. C a -> Type
+      where SD :: forall {a}. SC (D :: C a)
+    type instance Sing @(C a) = SC
+    instance SingKind a => SingKind (C a) where
+      type Demote (C a) = C (Demote a)
+      fromSing SD = D
+      toSing D = SomeSing SD
+    instance SingI D where
+      sing = SD
diff --git a/tests/compile-and-dump/Singletons/T565.hs b/tests/compile-and-dump/Singletons/T565.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T565.hs
@@ -0,0 +1,8 @@
+module T565 where
+
+import Data.Singletons.TH
+
+$(singletons [d|
+  data C a where
+    D :: forall {a}. C a
+  |])
diff --git a/tests/compile-and-dump/Singletons/T567.golden b/tests/compile-and-dump/Singletons/T567.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T567.golden
@@ -0,0 +1,61 @@
+Singletons/T567.hs:(0,0)-(0,0): Splicing declarations
+    withOptions defaultOptions {genSingKindInsts = False}
+      $ singletons
+          [d| type D1 :: forall k. forall (a :: k) -> Proxy a -> Type
+              type D2 :: forall k. forall (a :: k) -> Proxy a -> Type
+              type D3 :: forall k. forall (a :: k) -> Proxy a -> Type
+              type D4 :: forall k. forall (a :: k) -> Proxy a -> Type
+              
+              data D1 x p = MkD1
+              data D2 (x :: j) p = MkD2
+              data D3 x (p :: Proxy x) = MkD3
+              data D4 (x :: j) (p :: Proxy x) = MkD4 |]
+  ======>
+    type D1 :: forall k. forall (a :: k) -> Proxy a -> Type
+    data D1 x p = MkD1
+    type D2 :: forall k. forall (a :: k) -> Proxy a -> Type
+    data D2 (x :: j) p = MkD2
+    type D3 :: forall k. forall (a :: k) -> Proxy a -> Type
+    data D3 x (p :: Proxy x) = MkD3
+    type D4 :: forall k. forall (a :: k) -> Proxy a -> Type
+    data D4 (x :: j) (p :: Proxy x) = MkD4
+    type MkD1Sym0 :: forall k (x :: k) (p :: Proxy x). D1 x p
+    type family MkD1Sym0 @k @(x :: k) @(p :: Proxy x) :: D1 x p where
+      MkD1Sym0 = MkD1
+    type MkD2Sym0 :: forall j (x :: j) (p :: Proxy x). D2 x p
+    type family MkD2Sym0 @j @(x :: j) @(p :: Proxy x) :: D2 x p where
+      MkD2Sym0 = MkD2
+    type MkD3Sym0 :: forall k (x :: k) (p :: Proxy x). D3 x p
+    type family MkD3Sym0 @k @(x :: k) @(p :: Proxy x) :: D3 x p where
+      MkD3Sym0 = MkD3
+    type MkD4Sym0 :: forall j (x :: j) (p :: Proxy x). D4 x p
+    type family MkD4Sym0 @j @(x :: j) @(p :: Proxy x) :: D4 x p where
+      MkD4Sym0 = MkD4
+    type SD1 :: forall k (x :: k) (p :: Proxy x). D1 x p -> Type
+    data SD1 :: forall k (x :: k) (p :: Proxy x). D1 x p -> Type
+      where
+        SMkD1 :: forall k (x :: k) (p :: Proxy x). SD1 (MkD1 :: D1 x p)
+    type instance Sing @(D1 x p) = SD1
+    type SD2 :: forall j (x :: j) (p :: Proxy x). D2 x p -> Type
+    data SD2 :: forall j (x :: j) (p :: Proxy x). D2 x p -> Type
+      where
+        SMkD2 :: forall j (x :: j) (p :: Proxy x). SD2 (MkD2 :: D2 x p)
+    type instance Sing @(D2 x p) = SD2
+    type SD3 :: forall k (x :: k) (p :: Proxy x). D3 x p -> Type
+    data SD3 :: forall k (x :: k) (p :: Proxy x). D3 x p -> Type
+      where
+        SMkD3 :: forall k (x :: k) (p :: Proxy x). SD3 (MkD3 :: D3 x p)
+    type instance Sing @(D3 x p) = SD3
+    type SD4 :: forall j (x :: j) (p :: Proxy x). D4 x p -> Type
+    data SD4 :: forall j (x :: j) (p :: Proxy x). D4 x p -> Type
+      where
+        SMkD4 :: forall j (x :: j) (p :: Proxy x). SD4 (MkD4 :: D4 x p)
+    type instance Sing @(D4 x p) = SD4
+    instance SingI MkD1 where
+      sing = SMkD1
+    instance SingI MkD2 where
+      sing = SMkD2
+    instance SingI MkD3 where
+      sing = SMkD3
+    instance SingI MkD4 where
+      sing = SMkD4
diff --git a/tests/compile-and-dump/Singletons/T567.hs b/tests/compile-and-dump/Singletons/T567.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T567.hs
@@ -0,0 +1,21 @@
+module T567 where
+
+import Data.Kind (Type)
+import Data.Proxy (Proxy)
+import Data.Singletons.TH.Options
+import Data.Singletons.Base.TH
+
+$(withOptions defaultOptions{genSingKindInsts = False} $
+  singletons [d|
+  type D1 :: forall k. forall (a :: k) -> Proxy a -> Type
+  data D1 x p = MkD1
+
+  type D2 :: forall k. forall (a :: k) -> Proxy a -> Type
+  data D2 (x :: j) p = MkD2
+
+  type D3 :: forall k. forall (a :: k) -> Proxy a -> Type
+  data D3 x (p :: Proxy x) = MkD3
+
+  type D4 :: forall k. forall (a :: k) -> Proxy a -> Type
+  data D4 (x :: j) (p :: Proxy x) = MkD4
+  |])
diff --git a/tests/compile-and-dump/Singletons/T571.golden b/tests/compile-and-dump/Singletons/T571.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T571.golden
@@ -0,0 +1,65 @@
+Singletons/T571.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| f :: a -> a
+          f x = x |]
+  ======>
+    f :: a -> a
+    f x = x
+    type FSym0 :: (~>) a a
+    data FSym0 :: (~>) a a
+      where
+        FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
+                              FSym0 a0123456789876543210
+    type instance Apply @a @a FSym0 a0123456789876543210 = F a0123456789876543210
+    instance SuppressUnusedWarnings FSym0 where
+      suppressUnusedWarnings = snd ((,) FSym0KindInference ())
+    type FSym1 :: a -> a
+    type family FSym1 @a (a0123456789876543210 :: a) :: a where
+      FSym1 a0123456789876543210 = F a0123456789876543210
+    type F :: a -> a
+    type family F @a (a :: a) :: a where
+      F x = x
+    sF :: (forall (t :: a). Sing t -> Sing (F t :: a) :: Type)
+    sF (sX :: Sing x) = sX
+    instance SingI (FSym0 :: (~>) a a) where
+      sing = singFun1 @FSym0 sF
+Singletons/T571.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| g :: (a -> a) -> a -> a
+          g f x = f x |]
+  ======>
+    g :: (a -> a) -> a -> a
+    g f x = f x
+    type GSym0 :: (~>) ((~>) a a) ((~>) a a)
+    data GSym0 :: (~>) ((~>) a a) ((~>) a a)
+      where
+        GSym0KindInference :: SameKind (Apply GSym0 arg) (GSym1 arg) =>
+                              GSym0 a0123456789876543210
+    type instance Apply @((~>) a a) @((~>) a a) GSym0 a0123456789876543210 = GSym1 a0123456789876543210
+    instance SuppressUnusedWarnings GSym0 where
+      suppressUnusedWarnings = snd ((,) GSym0KindInference ())
+    type GSym1 :: (~>) a a -> (~>) a a
+    data GSym1 (a0123456789876543210 :: (~>) a a) :: (~>) a a
+      where
+        GSym1KindInference :: SameKind (Apply (GSym1 a0123456789876543210) arg) (GSym2 a0123456789876543210 arg) =>
+                              GSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @a @a (GSym1 a0123456789876543210) a0123456789876543210 = G a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (GSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) GSym1KindInference ())
+    type GSym2 :: (~>) a a -> a -> a
+    type family GSym2 @a (a0123456789876543210 :: (~>) a a) (a0123456789876543210 :: a) :: a where
+      GSym2 a0123456789876543210 a0123456789876543210 = G a0123456789876543210 a0123456789876543210
+    type G :: (~>) a a -> a -> a
+    type family G @a (a :: (~>) a a) (a :: a) :: a where
+      G f x = Apply f x
+    sG ::
+      (forall (t :: (~>) a a) (t :: a).
+       Sing t -> Sing t -> Sing (G t t :: a) :: Type)
+    sG (sF :: Sing f) (sX :: Sing x) = applySing sF sX
+    instance SingI (GSym0 :: (~>) ((~>) a a) ((~>) a a)) where
+      sing = singFun2 @GSym0 sG
+    instance SingI d => SingI (GSym1 (d :: (~>) a a) :: (~>) a a) where
+      sing = singFun1 @(GSym1 (d :: (~>) a a)) (sG (sing @d))
+    instance SingI1 (GSym1 :: (~>) a a -> (~>) a a) where
+      liftSing (s :: Sing (d :: (~>) a a))
+        = singFun1 @(GSym1 (d :: (~>) a a)) (sG s)
diff --git a/tests/compile-and-dump/Singletons/T571.hs b/tests/compile-and-dump/Singletons/T571.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T571.hs
@@ -0,0 +1,13 @@
+module T571 where
+
+import Data.Singletons.TH
+
+$(singletons [d|
+  f :: a -> a
+  f x = x
+  |])
+
+$(singletons [d|
+  g :: (a -> a) -> a -> a
+  g f x = f x
+  |])
diff --git a/tests/compile-and-dump/Singletons/T581.golden b/tests/compile-and-dump/Singletons/T581.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T581.golden
@@ -0,0 +1,243 @@
+Singletons/T581.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| class C1 a where
+            m1 :: forall b. a -> Maybe (a, b)
+            m1 _ = Nothing :: Maybe (a, b)
+          class C2 a where
+            m2 :: b -> Maybe a
+            m2 _ = Nothing :: Maybe a
+          class C3 a where
+            m3 :: forall b. a -> b -> (a, b)
+            m3 x y = (x, y) :: (a, b)
+          
+          instance C3 [a] where
+            m3 x y = (fmap (\ xx -> (xx :: a)) x, y)
+          instance C3 (Maybe a) where
+            m3 :: Maybe a -> b -> (Maybe a, b)
+            m3 x y = (fmap (\ xx -> (xx :: a)) x, y)
+          instance C2 (Maybe a) where
+            m2 _ = Nothing :: Maybe (Maybe a)
+          instance C2 [a] where
+            m2 :: b -> Maybe [a]
+            m2 _ = Nothing :: Maybe [a]
+          instance C1 [a] where
+            m1 :: forall b. [a] -> Maybe ([a], b)
+            m1 _ = Nothing :: Maybe ([a], b) |]
+  ======>
+    class C1 a where
+      m1 :: forall b. a -> Maybe (a, b)
+      m1 _ = Nothing :: Maybe (a, b)
+    instance C1 [a] where
+      m1 :: forall b. [a] -> Maybe ([a], b)
+      m1 _ = Nothing :: Maybe ([a], b)
+    class C2 a where
+      m2 :: b -> Maybe a
+      m2 _ = Nothing :: Maybe a
+    instance C2 [a] where
+      m2 :: b -> Maybe [a]
+      m2 _ = Nothing :: Maybe [a]
+    instance C2 (Maybe a) where
+      m2 _ = Nothing :: Maybe (Maybe a)
+    class C3 a where
+      m3 :: forall b. a -> b -> (a, b)
+      m3 x y = (x, y) :: (a, b)
+    instance C3 (Maybe a) where
+      m3 :: Maybe a -> b -> (Maybe a, b)
+      m3 x y = (fmap (\ xx -> xx :: a) x, y)
+    instance C3 [a] where
+      m3 x y = (fmap (\ xx -> xx :: a) x, y)
+    type M1Sym0 :: forall a b. (~>) a (Maybe (a, b))
+    data M1Sym0 :: (~>) a (Maybe (a, b))
+      where
+        M1Sym0KindInference :: SameKind (Apply M1Sym0 arg) (M1Sym1 arg) =>
+                               M1Sym0 a0123456789876543210
+    type instance Apply @a @(Maybe (a,
+                                    b)) M1Sym0 a0123456789876543210 = M1 a0123456789876543210
+    instance SuppressUnusedWarnings M1Sym0 where
+      suppressUnusedWarnings = snd ((,) M1Sym0KindInference ())
+    type M1Sym1 :: forall a b. a -> Maybe (a, b)
+    type family M1Sym1 @a @b (a0123456789876543210 :: a) :: Maybe (a,
+                                                                   b) where
+      M1Sym1 a0123456789876543210 = M1 a0123456789876543210
+    type M1_0123456789876543210 :: forall a b. a -> Maybe (a, b)
+    type family M1_0123456789876543210 @a @b (a :: a) :: Maybe (a,
+                                                                b) where
+      M1_0123456789876543210 @a @b (_ :: a) = NothingSym0 :: Maybe (a, b)
+    class PC1 a where
+      type family M1 (arg :: a) :: Maybe (a, b)
+      type M1 a = M1_0123456789876543210 a
+    type M2Sym0 :: forall b a. (~>) b (Maybe a)
+    data M2Sym0 :: (~>) b (Maybe a)
+      where
+        M2Sym0KindInference :: SameKind (Apply M2Sym0 arg) (M2Sym1 arg) =>
+                               M2Sym0 a0123456789876543210
+    type instance Apply @b @(Maybe a) M2Sym0 a0123456789876543210 = M2 a0123456789876543210
+    instance SuppressUnusedWarnings M2Sym0 where
+      suppressUnusedWarnings = snd ((,) M2Sym0KindInference ())
+    type M2Sym1 :: forall b a. b -> Maybe a
+    type family M2Sym1 @b @a (a0123456789876543210 :: b) :: Maybe a where
+      M2Sym1 a0123456789876543210 = M2 a0123456789876543210
+    type M2_0123456789876543210 :: forall a b. b -> Maybe a
+    type family M2_0123456789876543210 @a @b (a :: b) :: Maybe a where
+      M2_0123456789876543210 @a @b (_ :: b) = NothingSym0 :: Maybe a
+    class PC2 a where
+      type family M2 (arg :: b) :: Maybe a
+      type M2 a = M2_0123456789876543210 a
+    type M3Sym0 :: forall a b. (~>) a ((~>) b (a, b))
+    data M3Sym0 :: (~>) a ((~>) b (a, b))
+      where
+        M3Sym0KindInference :: SameKind (Apply M3Sym0 arg) (M3Sym1 arg) =>
+                               M3Sym0 a0123456789876543210
+    type instance Apply @a @((~>) b (a,
+                                     b)) M3Sym0 a0123456789876543210 = M3Sym1 a0123456789876543210
+    instance SuppressUnusedWarnings M3Sym0 where
+      suppressUnusedWarnings = snd ((,) M3Sym0KindInference ())
+    type M3Sym1 :: forall a b. a -> (~>) b (a, b)
+    data M3Sym1 (a0123456789876543210 :: a) :: (~>) b (a, b)
+      where
+        M3Sym1KindInference :: SameKind (Apply (M3Sym1 a0123456789876543210) arg) (M3Sym2 a0123456789876543210 arg) =>
+                               M3Sym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @(a,
+                             b) (M3Sym1 a0123456789876543210) a0123456789876543210 = M3 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (M3Sym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) M3Sym1KindInference ())
+    type M3Sym2 :: forall a b. a -> b -> (a, b)
+    type family M3Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (a,
+                                                                                         b) where
+      M3Sym2 a0123456789876543210 a0123456789876543210 = M3 a0123456789876543210 a0123456789876543210
+    type M3_0123456789876543210 :: forall a b. a -> b -> (a, b)
+    type family M3_0123456789876543210 @a @b (a :: a) (a :: b) :: (a,
+                                                                   b) where
+      M3_0123456789876543210 @a @b (x :: a) (y :: b) = Apply (Apply Tuple2Sym0 x) y :: (a,
+                                                                                        b)
+    class PC3 a where
+      type family M3 (arg :: a) (arg :: b) :: (a, b)
+      type M3 a a = M3_0123456789876543210 a a
+    type M1_0123456789876543210 :: forall a b. [a] -> Maybe ([a], b)
+    type family M1_0123456789876543210 @a @b (a :: [a]) :: Maybe ([a],
+                                                                  b) where
+      M1_0123456789876543210 @a @b (_ :: [a]) = NothingSym0 :: Maybe ([a],
+                                                                      b)
+    instance PC1 [a] where
+      type M1 a = M1_0123456789876543210 a
+    type M2_0123456789876543210 :: forall a b. b -> Maybe [a]
+    type family M2_0123456789876543210 @a @b (a :: b) :: Maybe [a] where
+      M2_0123456789876543210 @a @b (_ :: b) = NothingSym0 :: Maybe [a]
+    instance PC2 [a] where
+      type M2 a = M2_0123456789876543210 a
+    type M2_0123456789876543210 :: forall a b. b -> Maybe (Maybe a)
+    type family M2_0123456789876543210 @a @b (a :: b) :: Maybe (Maybe a) where
+      M2_0123456789876543210 @a @b (_ :: b) = NothingSym0 :: Maybe (Maybe a)
+    instance PC2 (Maybe a) where
+      type M2 a = M2_0123456789876543210 a
+    type family LamCases_0123456789876543210 a0123456789876543210 (x0123456789876543210 :: Maybe a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 a x y xx = xx :: a
+    data LamCases_0123456789876543210Sym0 a0123456789876543210 (x0123456789876543210 :: Maybe a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 y0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a0123456789876543210 (x0123456789876543210 :: Maybe a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type M3_0123456789876543210 :: forall a b. Maybe a
+                                               -> b -> (Maybe a, b)
+    type family M3_0123456789876543210 @a @b (a :: Maybe a) (a :: b) :: (Maybe a,
+                                                                         b) where
+      M3_0123456789876543210 @a @b (x :: Maybe a) (y :: b) = Apply (Apply Tuple2Sym0 (Apply (Apply FmapSym0 (LamCases_0123456789876543210Sym0 a x y)) x)) y
+    instance PC3 (Maybe a) where
+      type M3 a a = M3_0123456789876543210 a a
+    type family LamCases_0123456789876543210 a0123456789876543210 (x0123456789876543210 :: [a0123456789876543210]) (y0123456789876543210 :: b0123456789876543210) a_0123456789876543210 where
+      LamCases_0123456789876543210 a x y xx = xx :: a
+    data LamCases_0123456789876543210Sym0 a0123456789876543210 (x0123456789876543210 :: [a0123456789876543210]) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 y0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a0123456789876543210 (x0123456789876543210 :: [a0123456789876543210]) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210
+    type M3_0123456789876543210 :: forall a b. [a] -> b -> ([a], b)
+    type family M3_0123456789876543210 @a @b (a :: [a]) (a :: b) :: ([a],
+                                                                     b) where
+      M3_0123456789876543210 @a @b (x :: [a]) (y :: b) = Apply (Apply Tuple2Sym0 (Apply (Apply FmapSym0 (LamCases_0123456789876543210Sym0 a x y)) x)) y
+    instance PC3 [a] where
+      type M3 a a = M3_0123456789876543210 a a
+    class SC1 a where
+      sM1 :: forall b (t :: a). Sing t -> Sing (M1 t :: Maybe (a, b))
+      default sM1 ::
+                forall b (t :: a). ((M1 t :: Maybe (a, b))
+                                    ~ M1_0123456789876543210 t) =>
+                                   Sing t -> Sing (M1 t :: Maybe (a, b))
+      sM1 _ = SNothing :: Sing (NothingSym0 :: Maybe (a, b))
+    class SC2 a where
+      sM2 :: (forall (t :: b). Sing t -> Sing (M2 t :: Maybe a) :: Type)
+      default sM2 ::
+                (forall (t :: b).
+                 ((M2 t :: Maybe a) ~ M2_0123456789876543210 t) =>
+                 Sing t -> Sing (M2 t :: Maybe a) :: Type)
+      sM2 _ = SNothing :: Sing (NothingSym0 :: Maybe a)
+    class SC3 a where
+      sM3 ::
+        forall b (t :: a) (t :: b). Sing t
+                                    -> Sing t -> Sing (M3 t t :: (a, b))
+      default sM3 ::
+                forall b (t :: a) (t :: b). ((M3 t t :: (a, b))
+                                             ~ M3_0123456789876543210 t t) =>
+                                            Sing t -> Sing t -> Sing (M3 t t :: (a, b))
+      sM3 (sX :: Sing x) (sY :: Sing y)
+        = applySing (applySing (singFun2 @Tuple2Sym0 STuple2) sX) sY ::
+            Sing (Apply (Apply Tuple2Sym0 x) y :: (a, b))
+    instance SC1 [a] where
+      sM1 :: forall b (t :: [a]). Sing t -> Sing (M1 t :: Maybe ([a], b))
+      sM1 _ = SNothing :: Sing (NothingSym0 :: Maybe ([a], b))
+    instance SC2 [a] where
+      sM2 ::
+        (forall (t :: b). Sing t -> Sing (M2 t :: Maybe [a]) :: Type)
+      sM2 _ = SNothing :: Sing (NothingSym0 :: Maybe [a])
+    instance SC2 (Maybe a) where
+      sM2 _ = SNothing :: Sing (NothingSym0 :: Maybe (Maybe a))
+    instance SC3 (Maybe a) where
+      sM3 ::
+        (forall (t :: Maybe a) (t :: b).
+         Sing t -> Sing t -> Sing (M3 t t :: (Maybe a, b)) :: Type)
+      sM3 (sX :: Sing x) (sY :: Sing y)
+        = applySing
+            (applySing
+               (singFun2 @Tuple2Sym0 STuple2)
+               (applySing
+                  (applySing
+                     (singFun2 @FmapSym0 sFmap)
+                     (singFun1
+                        @(LamCases_0123456789876543210Sym0 a x y)
+                        (\cases (sXx :: Sing xx) -> sXx :: Sing (xx :: a))))
+                  sX))
+            sY
+    instance SC3 [a] where
+      sM3 (sX :: Sing x) (sY :: Sing y)
+        = applySing
+            (applySing
+               (singFun2 @Tuple2Sym0 STuple2)
+               (applySing
+                  (applySing
+                     (singFun2 @FmapSym0 sFmap)
+                     (singFun1
+                        @(LamCases_0123456789876543210Sym0 a x y)
+                        (\cases (sXx :: Sing xx) -> sXx :: Sing (xx :: a))))
+                  sX))
+            sY
+    instance SC1 a => SingI (M1Sym0 :: (~>) a (Maybe (a, b))) where
+      sing = singFun1 @M1Sym0 sM1
+    instance SC2 a => SingI (M2Sym0 :: (~>) b (Maybe a)) where
+      sing = singFun1 @M2Sym0 sM2
+    instance SC3 a => SingI (M3Sym0 :: (~>) a ((~>) b (a, b))) where
+      sing = singFun2 @M3Sym0 sM3
+    instance (SC3 a, SingI d) =>
+             SingI (M3Sym1 (d :: a) :: (~>) b (a, b)) where
+      sing = singFun1 @(M3Sym1 (d :: a)) (sM3 (sing @d))
+    instance SC3 a => SingI1 (M3Sym1 :: a -> (~>) b (a, b)) where
+      liftSing (s :: Sing (d :: a)) = singFun1 @(M3Sym1 (d :: a)) (sM3 s)
diff --git a/tests/compile-and-dump/Singletons/T581.hs b/tests/compile-and-dump/Singletons/T581.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T581.hs
@@ -0,0 +1,36 @@
+module T581 where
+
+import Data.Singletons.Base.TH
+import Prelude.Singletons
+
+$(singletons
+  [d| class C1 a where
+        m1 :: forall b. a -> Maybe (a, b)
+        m1 _ = Nothing :: Maybe (a, b)
+
+      instance C1 [a] where
+        m1 :: forall b. [a] -> Maybe ([a], b)
+        m1 _ = Nothing :: Maybe ([a], b)
+
+      class C2 a where
+        m2 :: b -> Maybe a
+        m2 _ = Nothing :: Maybe a
+
+      instance C2 [a] where
+        m2 :: b -> Maybe [a]
+        m2 _ = Nothing :: Maybe [a]
+
+      instance C2 (Maybe a) where
+        m2 _ = Nothing :: Maybe (Maybe a)
+
+      class C3 a where
+        m3 :: forall b. a -> b -> (a, b)
+        m3 x y = (x, y) :: (a, b)
+
+      instance C3 (Maybe a) where
+        m3 :: Maybe a -> b -> (Maybe a, b)
+        m3 x y = (fmap (\xx -> (xx :: a)) x, y)
+
+      instance C3 [a] where
+        m3 x y = (fmap (\xx -> (xx :: a)) x, y)
+    |])
diff --git a/tests/compile-and-dump/Singletons/T582.golden b/tests/compile-and-dump/Singletons/T582.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T582.golden
@@ -0,0 +1,150 @@
+Singletons/T582.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| infixl 4 type !!!
+          infixl 4 data %%%
+          infixl 4 type `Bar`
+          infixl 4 data `foo`
+          
+          foo :: a -> a -> a
+          x `foo` _ = x
+          (%%%) :: a -> a -> a
+          x %%% _ = x
+          
+          type Bar :: a -> a -> a
+          type (!!!) :: a -> a -> a
+          
+          type x `Bar` y = x
+          type x !!! y = x |]
+  ======>
+    infixl 4 data `foo`
+    foo :: a -> a -> a
+    foo x _ = x
+    infixl 4 type `Bar`
+    type Bar :: a -> a -> a
+    type Bar x y = x
+    infixl 4 data %%%
+    (%%%) :: a -> a -> a
+    (%%%) x _ = x
+    infixl 4 type !!!
+    type (!!!) :: a -> a -> a
+    type (!!!) x y = x
+    type BarSym0 :: (~>) a ((~>) a a)
+    data BarSym0 :: (~>) a ((~>) a a)
+      where
+        BarSym0KindInference :: SameKind (Apply BarSym0 arg) (BarSym1 arg) =>
+                                BarSym0 a0123456789876543210
+    type instance Apply @a @((~>) a a) BarSym0 a0123456789876543210 = BarSym1 a0123456789876543210
+    instance SuppressUnusedWarnings BarSym0 where
+      suppressUnusedWarnings = snd ((,) BarSym0KindInference ())
+    infixl 4 type `BarSym0`
+    type BarSym1 :: a -> (~>) a a
+    data BarSym1 (a0123456789876543210 :: a) :: (~>) a a
+      where
+        BarSym1KindInference :: SameKind (Apply (BarSym1 a0123456789876543210) arg) (BarSym2 a0123456789876543210 arg) =>
+                                BarSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @a @a (BarSym1 a0123456789876543210) a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (BarSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) BarSym1KindInference ())
+    infixl 4 type `BarSym1`
+    type BarSym2 :: a -> a -> a
+    type family BarSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
+      BarSym2 a0123456789876543210 a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210
+    infixl 4 type `BarSym2`
+    type (!!!@#@$) :: (~>) a ((~>) a a)
+    data (!!!@#@$) :: (~>) a ((~>) a a)
+      where
+        (:!!!@#@$###) :: SameKind (Apply (!!!@#@$) arg) ((!!!@#@$$) arg) =>
+                         (!!!@#@$) a0123456789876543210
+    type instance Apply @a @((~>) a a) (!!!@#@$) a0123456789876543210 = (!!!@#@$$) a0123456789876543210
+    instance SuppressUnusedWarnings (!!!@#@$) where
+      suppressUnusedWarnings = snd ((,) (:!!!@#@$###) ())
+    infixl 4 type !!!@#@$
+    type (!!!@#@$$) :: a -> (~>) a a
+    data (!!!@#@$$) (a0123456789876543210 :: a) :: (~>) a a
+      where
+        (:!!!@#@$$###) :: SameKind (Apply ((!!!@#@$$) a0123456789876543210) arg) ((!!!@#@$$$) a0123456789876543210 arg) =>
+                          (!!!@#@$$) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @a ((!!!@#@$$) a0123456789876543210) a0123456789876543210 = (!!!) a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings ((!!!@#@$$) a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) (:!!!@#@$$###) ())
+    infixl 4 type !!!@#@$$
+    type (!!!@#@$$$) :: a -> a -> a
+    type family (!!!@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
+      (!!!@#@$$$) a0123456789876543210 a0123456789876543210 = (!!!) a0123456789876543210 a0123456789876543210
+    infixl 4 type !!!@#@$$$
+    type (%%%@#@$) :: (~>) a ((~>) a a)
+    data (%%%@#@$) :: (~>) a ((~>) a a)
+      where
+        (:%%%@#@$###) :: SameKind (Apply (%%%@#@$) arg) ((%%%@#@$$) arg) =>
+                         (%%%@#@$) a0123456789876543210
+    type instance Apply @a @((~>) a a) (%%%@#@$) a0123456789876543210 = (%%%@#@$$) a0123456789876543210
+    instance SuppressUnusedWarnings (%%%@#@$) where
+      suppressUnusedWarnings = snd ((,) (:%%%@#@$###) ())
+    infixl 4 type %%%@#@$
+    type (%%%@#@$$) :: a -> (~>) a a
+    data (%%%@#@$$) (a0123456789876543210 :: a) :: (~>) a a
+      where
+        (:%%%@#@$$###) :: SameKind (Apply ((%%%@#@$$) a0123456789876543210) arg) ((%%%@#@$$$) a0123456789876543210 arg) =>
+                          (%%%@#@$$) a0123456789876543210 a0123456789876543210
+    type instance Apply @a @a ((%%%@#@$$) a0123456789876543210) a0123456789876543210 = (%%%) a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings ((%%%@#@$$) a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) (:%%%@#@$$###) ())
+    infixl 4 type %%%@#@$$
+    type (%%%@#@$$$) :: a -> a -> a
+    type family (%%%@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
+      (%%%@#@$$$) a0123456789876543210 a0123456789876543210 = (%%%) a0123456789876543210 a0123456789876543210
+    infixl 4 type %%%@#@$$$
+    type FooSym0 :: (~>) a ((~>) a a)
+    data FooSym0 :: (~>) a ((~>) a a)
+      where
+        FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
+                                FooSym0 a0123456789876543210
+    type instance Apply @a @((~>) a a) FooSym0 a0123456789876543210 = FooSym1 a0123456789876543210
+    instance SuppressUnusedWarnings FooSym0 where
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
+    infixl 4 type `FooSym0`
+    type FooSym1 :: a -> (~>) a a
+    data FooSym1 (a0123456789876543210 :: a) :: (~>) a a
+      where
+        FooSym1KindInference :: SameKind (Apply (FooSym1 a0123456789876543210) arg) (FooSym2 a0123456789876543210 arg) =>
+                                FooSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @a @a (FooSym1 a0123456789876543210) a0123456789876543210 = Foo a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (FooSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) FooSym1KindInference ())
+    infixl 4 type `FooSym1`
+    type FooSym2 :: a -> a -> a
+    type family FooSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where
+      FooSym2 a0123456789876543210 a0123456789876543210 = Foo a0123456789876543210 a0123456789876543210
+    infixl 4 type `FooSym2`
+    type (%%%) :: a -> a -> a
+    type family (%%%) @a (a :: a) (a :: a) :: a where
+      (%%%) x _ = x
+    type Foo :: a -> a -> a
+    type family Foo @a (a :: a) (a :: a) :: a where
+      Foo x _ = x
+    infixl 4 type %%%
+    infixl 4 type `Foo`
+    infixl 4 data %%%%
+    infixl 4 data `sFoo`
+    (%%%%) ::
+      (forall (t :: a) (t :: a).
+       Sing t -> Sing t -> Sing ((%%%) t t :: a) :: Type)
+    sFoo ::
+      (forall (t :: a) (t :: a).
+       Sing t -> Sing t -> Sing (Foo t t :: a) :: Type)
+    (%%%%) (sX :: Sing x) _ = sX
+    sFoo (sX :: Sing x) _ = sX
+    instance SingI ((%%%@#@$) :: (~>) a ((~>) a a)) where
+      sing = singFun2 @(%%%@#@$) (%%%%)
+    instance SingI d => SingI ((%%%@#@$$) (d :: a) :: (~>) a a) where
+      sing = singFun1 @((%%%@#@$$) (d :: a)) ((%%%%) (sing @d))
+    instance SingI1 ((%%%@#@$$) :: a -> (~>) a a) where
+      liftSing (s :: Sing (d :: a))
+        = singFun1 @((%%%@#@$$) (d :: a)) ((%%%%) s)
+    instance SingI (FooSym0 :: (~>) a ((~>) a a)) where
+      sing = singFun2 @FooSym0 sFoo
+    instance SingI d => SingI (FooSym1 (d :: a) :: (~>) a a) where
+      sing = singFun1 @(FooSym1 (d :: a)) (sFoo (sing @d))
+    instance SingI1 (FooSym1 :: a -> (~>) a a) where
+      liftSing (s :: Sing (d :: a))
+        = singFun1 @(FooSym1 (d :: a)) (sFoo s)
diff --git a/tests/compile-and-dump/Singletons/T582.hs b/tests/compile-and-dump/Singletons/T582.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T582.hs
@@ -0,0 +1,21 @@
+module T582 where
+
+import Data.Singletons.TH
+
+$(singletons [d|
+  infixl 4 data `foo`
+  foo :: a -> a -> a
+  x `foo` _ = x
+
+  infixl 4 type `Bar`
+  type Bar :: a -> a -> a
+  type x `Bar` y = x
+
+  infixl 4 data %%%
+  (%%%) :: a -> a -> a
+  x %%% _ = x
+
+  infixl 4 type !!!
+  type (!!!) :: a -> a -> a
+  type x !!! y = x
+  |])
diff --git a/tests/compile-and-dump/Singletons/T585.golden b/tests/compile-and-dump/Singletons/T585.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T585.golden
@@ -0,0 +1,40 @@
+Singletons/T585.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| konst :: forall a {b}. a -> b -> a
+          konst x _ = x |]
+  ======>
+    konst :: forall a {b}. a -> b -> a
+    konst x _ = x
+    type KonstSym0 :: forall a {b}. (~>) a ((~>) b a)
+    data KonstSym0 :: (~>) a ((~>) b a)
+      where
+        KonstSym0KindInference :: SameKind (Apply KonstSym0 arg) (KonstSym1 arg) =>
+                                  KonstSym0 a0123456789876543210
+    type instance Apply @a @((~>) b a) KonstSym0 a0123456789876543210 = KonstSym1 a0123456789876543210
+    instance SuppressUnusedWarnings KonstSym0 where
+      suppressUnusedWarnings = snd ((,) KonstSym0KindInference ())
+    type KonstSym1 :: forall a {b}. a -> (~>) b a
+    data KonstSym1 (a0123456789876543210 :: a) :: (~>) b a
+      where
+        KonstSym1KindInference :: SameKind (Apply (KonstSym1 a0123456789876543210) arg) (KonstSym2 a0123456789876543210 arg) =>
+                                  KonstSym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @b @a (KonstSym1 a0123456789876543210) a0123456789876543210 = Konst a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (KonstSym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) KonstSym1KindInference ())
+    type KonstSym2 :: forall a {b}. a -> b -> a
+    type family KonstSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: a where
+      KonstSym2 a0123456789876543210 a0123456789876543210 = Konst a0123456789876543210 a0123456789876543210
+    type Konst :: forall a {b}. a -> b -> a
+    type family Konst @a (a :: a) (a :: b) :: a where
+      Konst @a (x :: a) (_ :: b) = x
+    sKonst ::
+      forall a {b} (t :: a) (t :: b). Sing t
+                                      -> Sing t -> Sing (Konst t t :: a)
+    sKonst (sX :: Sing x) _ = sX
+    instance SingI (KonstSym0 :: (~>) a ((~>) b a)) where
+      sing = singFun2 @KonstSym0 sKonst
+    instance SingI d => SingI (KonstSym1 (d :: a) :: (~>) b a) where
+      sing = singFun1 @(KonstSym1 (d :: a)) (sKonst (sing @d))
+    instance SingI1 (KonstSym1 :: a -> (~>) b a) where
+      liftSing (s :: Sing (d :: a))
+        = singFun1 @(KonstSym1 (d :: a)) (sKonst s)
diff --git a/tests/compile-and-dump/Singletons/T585.hs b/tests/compile-and-dump/Singletons/T585.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T585.hs
@@ -0,0 +1,8 @@
+module T585 where
+
+import Data.Singletons.TH
+
+$(singletons [d|
+  konst :: forall a {b}. a -> b -> a
+  konst x _ = x
+  |])
diff --git a/tests/compile-and-dump/Singletons/T78.golden b/tests/compile-and-dump/Singletons/T78.golden
--- a/tests/compile-and-dump/Singletons/T78.golden
+++ b/tests/compile-and-dump/Singletons/T78.golden
@@ -14,9 +14,9 @@
       where
         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
                                 FooSym0 a0123456789876543210
-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210
+    type instance Apply @(Maybe Bool) @Bool FooSym0 a0123456789876543210 = Foo a0123456789876543210
     instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
     type FooSym1 :: Maybe Bool -> Bool
     type family FooSym1 (a0123456789876543210 :: Maybe Bool) :: Bool where
       FooSym1 a0123456789876543210 = Foo a0123456789876543210
@@ -26,9 +26,9 @@
       Foo ('Just 'True) = TrueSym0
       Foo 'Nothing = FalseSym0
     sFoo ::
-      forall (t :: Maybe Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)
+      (forall (t :: Maybe Bool). Sing t -> Sing (Foo t :: Bool) :: Type)
     sFoo (SJust SFalse) = SFalse
     sFoo (SJust STrue) = STrue
     sFoo SNothing = SFalse
     instance SingI (FooSym0 :: (~>) (Maybe Bool) Bool) where
-      sing = (singFun1 @FooSym0) sFoo
+      sing = singFun1 @FooSym0 sFoo
diff --git a/tests/compile-and-dump/Singletons/T89.golden b/tests/compile-and-dump/Singletons/T89.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T89.golden
@@ -0,0 +1,59 @@
+Singletons/T89.hs:0:0:: Splicing declarations
+    singletons
+      [d| data Foo
+            = Foo
+            deriving (Enum) |]
+  ======>
+    data Foo
+      = Foo
+      deriving Enum
+    type FooSym0 :: Foo
+    type family FooSym0 :: Foo where
+      FooSym0 = Foo
+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where
+      LamCases_0123456789876543210 n 'True = FooSym0
+      LamCases_0123456789876543210 n 'False = Apply ErrorSym0 (FromString "toEnum: bad argument")
+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where
+      suppressUnusedWarnings
+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210
+    type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural
+                                       -> Foo
+    type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: Foo where
+      ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0))
+    type FromEnum_0123456789876543210 :: Foo
+                                         -> GHC.Internal.Bignum.Natural.Natural
+    type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Internal.Bignum.Natural.Natural where
+      FromEnum_0123456789876543210 Foo = FromInteger 0
+    instance PEnum Foo where
+      type ToEnum a = ToEnum_0123456789876543210 a
+      type FromEnum a = FromEnum_0123456789876543210 a
+    data SFoo :: Foo -> Type where SFoo :: SFoo (Foo :: Foo)
+    type instance Sing @Foo = SFoo
+    instance SingKind Foo where
+      type Demote Foo = Foo
+      fromSing SFoo = Foo
+      toSing Foo = SomeSing SFoo
+    instance SEnum Foo where
+      sToEnum (sN :: Sing n)
+        = applySing
+            (singFun1
+               @(LamCases_0123456789876543210Sym0 n)
+               (\cases
+                  STrue -> SFoo
+                  SFalse
+                    -> applySing
+                         (singFun1 @ErrorSym0 sError)
+                         (sFromString (sing :: Sing "toEnum: bad argument"))))
+            (applySing
+               (applySing (singFun2 @(==@#@$) (%==)) sN)
+               (sFromInteger (sing :: Sing 0)))
+      sFromEnum SFoo = sFromInteger (sing :: Sing 0)
+    instance SingI Foo where
+      sing = SFoo
diff --git a/tests/compile-and-dump/Singletons/T89.hs b/tests/compile-and-dump/Singletons/T89.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T89.hs
@@ -0,0 +1,6 @@
+{-# LANGUAGE OverloadedStrings #-}
+module T89 where
+
+import Data.Singletons.Base.TH
+
+$(singletons [d|data Foo = Foo deriving (Enum)|])
diff --git a/tests/compile-and-dump/Singletons/TopLevelPatterns.golden b/tests/compile-and-dump/Singletons/TopLevelPatterns.golden
--- a/tests/compile-and-dump/Singletons/TopLevelPatterns.golden
+++ b/tests/compile-and-dump/Singletons/TopLevelPatterns.golden
@@ -16,19 +16,19 @@
       where
         BarSym0KindInference :: SameKind (Apply BarSym0 arg) (BarSym1 arg) =>
                                 BarSym0 a0123456789876543210
-    type instance Apply BarSym0 a0123456789876543210 = BarSym1 a0123456789876543210
+    type instance Apply @Bool @((~>) Bool Foo) BarSym0 a0123456789876543210 = BarSym1 a0123456789876543210
     instance SuppressUnusedWarnings BarSym0 where
       suppressUnusedWarnings
-        = Data.Tuple.snd (((,) BarSym0KindInference) ())
+        = GHC.Internal.Data.Tuple.snd ((,) BarSym0KindInference ())
     type BarSym1 :: Bool -> (~>) Bool Foo
     data BarSym1 (a0123456789876543210 :: Bool) :: (~>) Bool Foo
       where
         BarSym1KindInference :: SameKind (Apply (BarSym1 a0123456789876543210) arg) (BarSym2 a0123456789876543210 arg) =>
                                 BarSym1 a0123456789876543210 a0123456789876543210
-    type instance Apply (BarSym1 a0123456789876543210) a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210
+    type instance Apply @Bool @Foo (BarSym1 a0123456789876543210) a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210
     instance SuppressUnusedWarnings (BarSym1 a0123456789876543210) where
       suppressUnusedWarnings
-        = Data.Tuple.snd (((,) BarSym1KindInference) ())
+        = GHC.Internal.Data.Tuple.snd ((,) BarSym1KindInference ())
     type BarSym2 :: Bool -> Bool -> Foo
     type family BarSym2 (a0123456789876543210 :: Bool) (a0123456789876543210 :: Bool) :: Foo where
       BarSym2 a0123456789876543210 a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210
@@ -50,31 +50,29 @@
     type instance Sing @Foo = SFoo
     instance SingKind Foo where
       type Demote Foo = Foo
-      fromSing (SBar b b) = (Bar (fromSing b)) (fromSing b)
+      fromSing (SBar b b) = Bar (fromSing b) (fromSing b)
       toSing (Bar (b :: Demote Bool) (b :: Demote Bool))
-        = case
-              ((,) (toSing b :: SomeSing Bool)) (toSing b :: SomeSing Bool)
-          of
-            (,) (SomeSing c) (SomeSing c) -> SomeSing ((SBar c) c)
+        = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SBar c c))
+            (toSing b :: SomeSing Bool) (toSing b :: SomeSing Bool)
     instance SingI False where
       sing = SFalse
     instance SingI True where
       sing = STrue
     instance (SingI n, SingI n) =>
              SingI (Bar (n :: Bool) (n :: Bool)) where
-      sing = (SBar sing) sing
+      sing = SBar sing sing
     instance SingI n => SingI1 (Bar (n :: Bool)) where
       liftSing = SBar sing
     instance SingI2 Bar where
       liftSing2 = SBar
     instance SingI (BarSym0 :: (~>) Bool ((~>) Bool Foo)) where
-      sing = (singFun2 @BarSym0) SBar
+      sing = singFun2 @BarSym0 SBar
     instance SingI d =>
              SingI (BarSym1 (d :: Bool) :: (~>) Bool Foo) where
-      sing = (singFun1 @(BarSym1 (d :: Bool))) (SBar (sing @d))
+      sing = singFun1 @(BarSym1 (d :: Bool)) (SBar (sing @d))
     instance SingI1 (BarSym1 :: Bool -> (~>) Bool Foo) where
       liftSing (s :: Sing (d :: Bool))
-        = (singFun1 @(BarSym1 (d :: Bool))) (SBar s)
+        = singFun1 @(BarSym1 (d :: Bool)) (SBar s)
 Singletons/TopLevelPatterns.hs:(0,0)-(0,0): Splicing declarations
     singletons
       [d| otherwise :: Bool
@@ -110,32 +108,120 @@
     (h, i) = (f, g)
     j :: Bool
     k :: Bool
-    Bar j k = (Bar True) (h False)
+    Bar j k = Bar True (h False)
     l :: Bool
     m :: Bool
     [l, m] = [not True, id False]
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 '[_,
-                                 y_0123456789876543210] = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 '[y_0123456789876543210,
-                                 _] = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 ('Bar _ y_0123456789876543210) = y_0123456789876543210
-    type family Case_0123456789876543210 t where
-      Case_0123456789876543210 ('Bar y_0123456789876543210 _) = y_0123456789876543210
-    type family Case_0123456789876543210 a_0123456789876543210 t where
-      Case_0123456789876543210 a_0123456789876543210 '(_,
-                                                       y_0123456789876543210) = y_0123456789876543210
-    type family Case_0123456789876543210 a_0123456789876543210 t where
-      Case_0123456789876543210 a_0123456789876543210 '(y_0123456789876543210,
-                                                       _) = y_0123456789876543210
-    type family Case_0123456789876543210 a_0123456789876543210 t where
-      Case_0123456789876543210 a_0123456789876543210 '[_,
-                                                       y_0123456789876543210] = y_0123456789876543210
-    type family Case_0123456789876543210 a_0123456789876543210 t where
-      Case_0123456789876543210 a_0123456789876543210 '[y_0123456789876543210,
-                                                       _] = y_0123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 '[_,
+                                     y_0123456789876543210] = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
+      suppressUnusedWarnings
+        = GHC.Internal.Data.Tuple.snd
+            ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 '[y_0123456789876543210,
+                                     _] = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
+      suppressUnusedWarnings
+        = GHC.Internal.Data.Tuple.snd
+            ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 ('Bar _ y_0123456789876543210) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
+      suppressUnusedWarnings
+        = GHC.Internal.Data.Tuple.snd
+            ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 a_0123456789876543210 where
+      LamCases_0123456789876543210 ('Bar y_0123456789876543210 _) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply LamCases_0123456789876543210Sym0 arg) (LamCases_0123456789876543210Sym1 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings LamCases_0123456789876543210Sym0 where
+      suppressUnusedWarnings
+        = GHC.Internal.Data.Tuple.snd
+            ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (a_01234567898765432100123456789876543210 :: Bool) a_0123456789876543210 where
+      LamCases_0123456789876543210 a_0123456789876543210 '(_,
+                                                           y_0123456789876543210) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 (a_01234567898765432100123456789876543210 :: Bool) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = GHC.Internal.Data.Tuple.snd
+            ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (a_01234567898765432100123456789876543210 :: Bool) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (a_01234567898765432100123456789876543210 :: Bool) a_0123456789876543210 where
+      LamCases_0123456789876543210 a_0123456789876543210 '(y_0123456789876543210,
+                                                           _) = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 (a_01234567898765432100123456789876543210 :: Bool) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = GHC.Internal.Data.Tuple.snd
+            ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (a_01234567898765432100123456789876543210 :: Bool) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (a_01234567898765432100123456789876543210 :: Bool) a_0123456789876543210 where
+      LamCases_0123456789876543210 a_0123456789876543210 '[_,
+                                                           y_0123456789876543210] = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 (a_01234567898765432100123456789876543210 :: Bool) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = GHC.Internal.Data.Tuple.snd
+            ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (a_01234567898765432100123456789876543210 :: Bool) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type family LamCases_0123456789876543210 (a_01234567898765432100123456789876543210 :: Bool) a_0123456789876543210 where
+      LamCases_0123456789876543210 a_0123456789876543210 '[y_0123456789876543210,
+                                                           _] = y_0123456789876543210
+    data LamCases_0123456789876543210Sym0 (a_01234567898765432100123456789876543210 :: Bool) a_01234567898765432100123456789876543210
+      where
+        LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 arg) =>
+                                                         LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
+    instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a_01234567898765432100123456789876543210) where
+      suppressUnusedWarnings
+        = GHC.Internal.Data.Tuple.snd
+            ((,) LamCases_0123456789876543210Sym0KindInference ())
+    type family LamCases_0123456789876543210Sym1 (a_01234567898765432100123456789876543210 :: Bool) a_01234567898765432100123456789876543210 where
+      LamCases_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210
     type MSym0 :: Bool
     type family MSym0 :: Bool where
       MSym0 = M
@@ -157,10 +243,10 @@
       where
         ISym0KindInference :: SameKind (Apply ISym0 arg) (ISym1 arg) =>
                               ISym0 a0123456789876543210
-    type instance Apply ISym0 a0123456789876543210 = I a0123456789876543210
+    type instance Apply @Bool @Bool ISym0 a0123456789876543210 = I a0123456789876543210
     instance SuppressUnusedWarnings ISym0 where
       suppressUnusedWarnings
-        = Data.Tuple.snd (((,) ISym0KindInference) ())
+        = GHC.Internal.Data.Tuple.snd ((,) ISym0KindInference ())
     type ISym1 :: Bool -> Bool
     type family ISym1 (a0123456789876543210 :: Bool) :: Bool where
       ISym1 a0123456789876543210 = I a0123456789876543210
@@ -169,10 +255,10 @@
       where
         HSym0KindInference :: SameKind (Apply HSym0 arg) (HSym1 arg) =>
                               HSym0 a0123456789876543210
-    type instance Apply HSym0 a0123456789876543210 = H a0123456789876543210
+    type instance Apply @Bool @Bool HSym0 a0123456789876543210 = H a0123456789876543210
     instance SuppressUnusedWarnings HSym0 where
       suppressUnusedWarnings
-        = Data.Tuple.snd (((,) HSym0KindInference) ())
+        = GHC.Internal.Data.Tuple.snd ((,) HSym0KindInference ())
     type HSym1 :: Bool -> Bool
     type family HSym1 (a0123456789876543210 :: Bool) :: Bool where
       HSym1 a0123456789876543210 = H a0123456789876543210
@@ -183,10 +269,10 @@
       where
         GSym0KindInference :: SameKind (Apply GSym0 arg) (GSym1 arg) =>
                               GSym0 a0123456789876543210
-    type instance Apply GSym0 a0123456789876543210 = G a0123456789876543210
+    type instance Apply @Bool @Bool GSym0 a0123456789876543210 = G a0123456789876543210
     instance SuppressUnusedWarnings GSym0 where
       suppressUnusedWarnings
-        = Data.Tuple.snd (((,) GSym0KindInference) ())
+        = GHC.Internal.Data.Tuple.snd ((,) GSym0KindInference ())
     type GSym1 :: Bool -> Bool
     type family GSym1 (a0123456789876543210 :: Bool) :: Bool where
       GSym1 a0123456789876543210 = G a0123456789876543210
@@ -195,10 +281,10 @@
       where
         FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>
                               FSym0 a0123456789876543210
-    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210
+    type instance Apply @Bool @Bool FSym0 a0123456789876543210 = F a0123456789876543210
     instance SuppressUnusedWarnings FSym0 where
       suppressUnusedWarnings
-        = Data.Tuple.snd (((,) FSym0KindInference) ())
+        = GHC.Internal.Data.Tuple.snd ((,) FSym0KindInference ())
     type FSym1 :: Bool -> Bool
     type family FSym1 (a0123456789876543210 :: Bool) :: Bool where
       FSym1 a0123456789876543210 = F a0123456789876543210
@@ -211,10 +297,10 @@
       where
         NotSym0KindInference :: SameKind (Apply NotSym0 arg) (NotSym1 arg) =>
                                 NotSym0 a0123456789876543210
-    type instance Apply NotSym0 a0123456789876543210 = Not a0123456789876543210
+    type instance Apply @Bool @Bool NotSym0 a0123456789876543210 = Not a0123456789876543210
     instance SuppressUnusedWarnings NotSym0 where
       suppressUnusedWarnings
-        = Data.Tuple.snd (((,) NotSym0KindInference) ())
+        = GHC.Internal.Data.Tuple.snd ((,) NotSym0KindInference ())
     type NotSym1 :: Bool -> Bool
     type family NotSym1 (a0123456789876543210 :: Bool) :: Bool where
       NotSym1 a0123456789876543210 = Not a0123456789876543210
@@ -223,46 +309,46 @@
       where
         IdSym0KindInference :: SameKind (Apply IdSym0 arg) (IdSym1 arg) =>
                                IdSym0 a0123456789876543210
-    type instance Apply IdSym0 a0123456789876543210 = Id a0123456789876543210
+    type instance Apply @a @a IdSym0 a0123456789876543210 = Id a0123456789876543210
     instance SuppressUnusedWarnings IdSym0 where
       suppressUnusedWarnings
-        = Data.Tuple.snd (((,) IdSym0KindInference) ())
+        = GHC.Internal.Data.Tuple.snd ((,) IdSym0KindInference ())
     type IdSym1 :: a -> a
-    type family IdSym1 (a0123456789876543210 :: a) :: a where
+    type family IdSym1 @a (a0123456789876543210 :: a) :: a where
       IdSym1 a0123456789876543210 = Id a0123456789876543210
     type OtherwiseSym0 :: Bool
     type family OtherwiseSym0 :: Bool where
       OtherwiseSym0 = Otherwise
     type M :: Bool
     type family M :: Bool where
-      M = Case_0123456789876543210 X_0123456789876543210Sym0
+      M = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type L :: Bool
     type family L :: Bool where
-      L = Case_0123456789876543210 X_0123456789876543210Sym0
+      L = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type family X_0123456789876543210 where
       X_0123456789876543210 = Apply (Apply (:@#@$) (Apply NotSym0 TrueSym0)) (Apply (Apply (:@#@$) (Apply IdSym0 FalseSym0)) NilSym0)
     type K :: Bool
     type family K :: Bool where
-      K = Case_0123456789876543210 X_0123456789876543210Sym0
+      K = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type J :: Bool
     type family J :: Bool where
-      J = Case_0123456789876543210 X_0123456789876543210Sym0
+      J = Apply LamCases_0123456789876543210Sym0 X_0123456789876543210Sym0
     type family X_0123456789876543210 where
       X_0123456789876543210 = Apply (Apply BarSym0 TrueSym0) (Apply HSym0 FalseSym0)
     type I :: Bool -> Bool
     type family I (a :: Bool) :: Bool where
-      I a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210
+      I a_0123456789876543210 = Apply (Apply (LamCases_0123456789876543210Sym0 a_0123456789876543210) X_0123456789876543210Sym0) a_0123456789876543210
     type H :: Bool -> Bool
     type family H (a :: Bool) :: Bool where
-      H a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210
+      H a_0123456789876543210 = Apply (Apply (LamCases_0123456789876543210Sym0 a_0123456789876543210) X_0123456789876543210Sym0) a_0123456789876543210
     type family X_0123456789876543210 where
       X_0123456789876543210 = Apply (Apply Tuple2Sym0 FSym0) GSym0
     type G :: Bool -> Bool
     type family G (a :: Bool) :: Bool where
-      G a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210
+      G a_0123456789876543210 = Apply (Apply (LamCases_0123456789876543210Sym0 a_0123456789876543210) X_0123456789876543210Sym0) a_0123456789876543210
     type F :: Bool -> Bool
     type family F (a :: Bool) :: Bool where
-      F a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210
+      F a_0123456789876543210 = Apply (Apply (LamCases_0123456789876543210Sym0 a_0123456789876543210) X_0123456789876543210Sym0) a_0123456789876543210
     type family X_0123456789876543210 where
       X_0123456789876543210 = Apply (Apply (:@#@$) NotSym0) (Apply (Apply (:@#@$) IdSym0) NilSym0)
     type family False_ where
@@ -272,125 +358,143 @@
       Not 'True = FalseSym0
       Not 'False = TrueSym0
     type Id :: a -> a
-    type family Id (a :: a) :: a where
+    type family Id @a (a :: a) :: a where
       Id x = x
     type Otherwise :: Bool
     type family Otherwise :: Bool where
       Otherwise = TrueSym0
-    sM :: Sing (MSym0 :: Bool)
-    sL :: Sing (LSym0 :: Bool)
-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0
-    sK :: Sing (KSym0 :: Bool)
-    sJ :: Sing (JSym0 :: Bool)
-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0
-    sI :: forall (t :: Bool). Sing t -> Sing (Apply ISym0 t :: Bool)
-    sH :: forall (t :: Bool). Sing t -> Sing (Apply HSym0 t :: Bool)
-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0
-    sG :: forall (t :: Bool). Sing t -> Sing (Apply GSym0 t :: Bool)
-    sF :: forall (t :: Bool). Sing t -> Sing (Apply FSym0 t :: Bool)
-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0
-    sFalse_ :: Sing @_ False_Sym0
+    sM :: (Sing (M :: Bool) :: Type)
+    sL :: (Sing (L :: Bool) :: Type)
+    sX_0123456789876543210 :: Sing @_ X_0123456789876543210
+    sK :: (Sing (K :: Bool) :: Type)
+    sJ :: (Sing (J :: Bool) :: Type)
+    sX_0123456789876543210 :: Sing @_ X_0123456789876543210
+    sI :: (forall (t :: Bool). Sing t -> Sing (I t :: Bool) :: Type)
+    sH :: (forall (t :: Bool). Sing t -> Sing (H t :: Bool) :: Type)
+    sX_0123456789876543210 :: Sing @_ X_0123456789876543210
+    sG :: (forall (t :: Bool). Sing t -> Sing (G t :: Bool) :: Type)
+    sF :: (forall (t :: Bool). Sing t -> Sing (F t :: Bool) :: Type)
+    sX_0123456789876543210 :: Sing @_ X_0123456789876543210
+    sFalse_ :: Sing @_ False_
     sNot ::
-      forall (t :: Bool). Sing t -> Sing (Apply NotSym0 t :: Bool)
-    sId :: forall a (t :: a). Sing t -> Sing (Apply IdSym0 t :: a)
-    sOtherwise :: Sing (OtherwiseSym0 :: Bool)
+      (forall (t :: Bool). Sing t -> Sing (Not t :: Bool) :: Type)
+    sId :: (forall (t :: a). Sing t -> Sing (Id t :: a) :: Type)
+    sOtherwise :: (Sing (Otherwise :: Bool) :: Type)
     sM
-      = (GHC.Base.id
-           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)))
-          (case sX_0123456789876543210 of
-             SCons _
-                   (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) SNil)
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (SCons _
+                       (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)
+                              SNil))
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sL
-      = (GHC.Base.id
-           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)))
-          (case sX_0123456789876543210 of
-             SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)
-                   (SCons _ SNil)
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)
+                       (SCons _ SNil))
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sX_0123456789876543210
-      = (applySing
-           ((applySing ((singFun2 @(:@#@$)) SCons))
-              ((applySing ((singFun1 @NotSym0) sNot)) STrue)))
-          ((applySing
-              ((applySing ((singFun2 @(:@#@$)) SCons))
-                 ((applySing ((singFun1 @IdSym0) sId)) SFalse)))
+      = applySing
+          (applySing
+             (singFun2 @(:@#@$) SCons)
+             (applySing (singFun1 @NotSym0 sNot) STrue))
+          (applySing
+             (applySing
+                (singFun2 @(:@#@$) SCons)
+                (applySing (singFun1 @IdSym0 sId) SFalse))
              SNil)
     sK
-      = (GHC.Base.id
-           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)))
-          (case sX_0123456789876543210 of
-             SBar _ (sY_0123456789876543210 :: Sing y_0123456789876543210)
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (SBar _ (sY_0123456789876543210 :: Sing y_0123456789876543210))
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sJ
-      = (GHC.Base.id
-           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)))
-          (case sX_0123456789876543210 of
-             SBar (sY_0123456789876543210 :: Sing y_0123456789876543210) _
-               -> sY_0123456789876543210)
+      = applySing
+          (singFun1
+             @LamCases_0123456789876543210Sym0
+             (\cases
+                (SBar (sY_0123456789876543210 :: Sing y_0123456789876543210) _)
+                  -> sY_0123456789876543210))
+          sX_0123456789876543210
     sX_0123456789876543210
-      = (applySing ((applySing ((singFun2 @BarSym0) SBar)) STrue))
-          ((applySing ((singFun1 @HSym0) sH)) SFalse)
+      = applySing
+          (applySing (singFun2 @BarSym0 SBar) STrue)
+          (applySing (singFun1 @HSym0 sH) SFalse)
     sI (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing
-           ((GHC.Base.id
-               @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))
-              (case sX_0123456789876543210 of
-                 STuple2 _ (sY_0123456789876543210 :: Sing y_0123456789876543210)
-                   -> sY_0123456789876543210)))
+      = applySing
+          (applySing
+             (singFun1
+                @(LamCases_0123456789876543210Sym0 a_0123456789876543210)
+                (\cases
+                   (STuple2 _ (sY_0123456789876543210 :: Sing y_0123456789876543210))
+                     -> sY_0123456789876543210))
+             sX_0123456789876543210)
           sA_0123456789876543210
     sH (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing
-           ((GHC.Base.id
-               @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))
-              (case sX_0123456789876543210 of
-                 STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _
-                   -> sY_0123456789876543210)))
+      = applySing
+          (applySing
+             (singFun1
+                @(LamCases_0123456789876543210Sym0 a_0123456789876543210)
+                (\cases
+                   (STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _)
+                     -> sY_0123456789876543210))
+             sX_0123456789876543210)
           sA_0123456789876543210
     sX_0123456789876543210
-      = (applySing
-           ((applySing ((singFun2 @Tuple2Sym0) STuple2))
-              ((singFun1 @FSym0) sF)))
-          ((singFun1 @GSym0) sG)
+      = applySing
+          (applySing (singFun2 @Tuple2Sym0 STuple2) (singFun1 @FSym0 sF))
+          (singFun1 @GSym0 sG)
     sG (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing
-           ((GHC.Base.id
-               @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))
-              (case sX_0123456789876543210 of
-                 SCons _
-                       (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) SNil)
-                   -> sY_0123456789876543210)))
+      = applySing
+          (applySing
+             (singFun1
+                @(LamCases_0123456789876543210Sym0 a_0123456789876543210)
+                (\cases
+                   (SCons _
+                          (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)
+                                 SNil))
+                     -> sY_0123456789876543210))
+             sX_0123456789876543210)
           sA_0123456789876543210
     sF (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (applySing
-           ((GHC.Base.id
-               @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))
-              (case sX_0123456789876543210 of
-                 SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)
-                       (SCons _ SNil)
-                   -> sY_0123456789876543210)))
+      = applySing
+          (applySing
+             (singFun1
+                @(LamCases_0123456789876543210Sym0 a_0123456789876543210)
+                (\cases
+                   (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)
+                          (SCons _ SNil))
+                     -> sY_0123456789876543210))
+             sX_0123456789876543210)
           sA_0123456789876543210
     sX_0123456789876543210
-      = (applySing
-           ((applySing ((singFun2 @(:@#@$)) SCons))
-              ((singFun1 @NotSym0) sNot)))
-          ((applySing
-              ((applySing ((singFun2 @(:@#@$)) SCons)) ((singFun1 @IdSym0) sId)))
-             SNil)
+      = applySing
+          (applySing (singFun2 @(:@#@$) SCons) (singFun1 @NotSym0 sNot))
+          (applySing
+             (applySing (singFun2 @(:@#@$) SCons) (singFun1 @IdSym0 sId)) SNil)
     sFalse_ = SFalse
     sNot STrue = SFalse
     sNot SFalse = STrue
     sId (sX :: Sing x) = sX
     sOtherwise = STrue
     instance SingI (ISym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @ISym0) sI
+      sing = singFun1 @ISym0 sI
     instance SingI (HSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @HSym0) sH
+      sing = singFun1 @HSym0 sH
     instance SingI (GSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @GSym0) sG
+      sing = singFun1 @GSym0 sG
     instance SingI (FSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @FSym0) sF
+      sing = singFun1 @FSym0 sF
     instance SingI (NotSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @NotSym0) sNot
+      sing = singFun1 @NotSym0 sNot
     instance SingI (IdSym0 :: (~>) a a) where
-      sing = (singFun1 @IdSym0) sId
+      sing = singFun1 @IdSym0 sId
diff --git a/tests/compile-and-dump/Singletons/TypeAbstractions.golden b/tests/compile-and-dump/Singletons/TypeAbstractions.golden
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/TypeAbstractions.golden
@@ -0,0 +1,347 @@
+Singletons/TypeAbstractions.hs:(0,0)-(0,0): Splicing declarations
+    withOptions defaultOptions {genSingKindInsts = False}
+      $ singletons
+          [d| type D1 :: forall j k. j -> k -> Type
+              type D2 :: forall j k. j -> k -> Type
+              type D3 :: forall j. j -> forall k. k -> Type
+              type D4 :: forall (a :: Type). Type
+              type C1 :: forall j k. j -> k -> Constraint
+              type C2 :: forall j k. j -> k -> Constraint
+              type C3 :: forall j. j -> forall k. k -> Constraint
+              type C4 :: forall (a :: Type). Constraint
+              type TF :: forall j. j -> forall k. k -> Type
+              type TS :: forall j. j -> forall k. k -> Type
+              
+              data D1 @j @k (a :: j) (b :: k) = MkD1 (Proxy a) (Proxy b)
+              data D2 @x @y (a :: x) (b :: y) = MkD2 (Proxy a) (Proxy b)
+              data D3 @j (a :: j) @k (b :: k) = MkD3 (Proxy a) (Proxy b)
+              data D4 @a = MkD4 a
+              class C1 @j @k (a :: j) (b :: k) where
+                meth1 :: Proxy a -> Proxy b
+              class C2 @x @y (a :: x) (b :: y) where
+                meth2 :: Proxy a -> Proxy b
+              class C3 @j (a :: j) @k (b :: k) where
+                meth3 :: Proxy a -> Proxy b
+              class C4 @a where
+                meth4 :: a
+              type family TF @j (a :: j) @k (b :: k) where
+                TF @j _ @k _ = (j, k)
+              type TS @j (a :: j) @k (b :: k) = (j, k) |]
+  ======>
+    type D1 :: forall j k. j -> k -> Type
+    data D1 @j @k (a :: j) (b :: k) = MkD1 (Proxy a) (Proxy b)
+    type D2 :: forall j k. j -> k -> Type
+    data D2 @x @y (a :: x) (b :: y) = MkD2 (Proxy a) (Proxy b)
+    type D3 :: forall j. j -> forall k. k -> Type
+    data D3 @j (a :: j) @k (b :: k) = MkD3 (Proxy a) (Proxy b)
+    type D4 :: forall (a :: Type). Type
+    data D4 @a = MkD4 a
+    type C1 :: forall j k. j -> k -> Constraint
+    class C1 @j @k (a :: j) (b :: k) where
+      meth1 :: Proxy a -> Proxy b
+    type C2 :: forall j k. j -> k -> Constraint
+    class C2 @x @y (a :: x) (b :: y) where
+      meth2 :: Proxy a -> Proxy b
+    type C3 :: forall j. j -> forall k. k -> Constraint
+    class C3 @j (a :: j) @k (b :: k) where
+      meth3 :: Proxy a -> Proxy b
+    type C4 :: forall (a :: Type). Constraint
+    class C4 @a where
+      meth4 :: a
+    type TF :: forall j. j -> forall k. k -> Type
+    type family TF @j (a :: j) @k (b :: k) where
+      TF @j _ @k _ = (j, k)
+    type TS :: forall j. j -> forall k. k -> Type
+    type TS @j (a :: j) @k (b :: k) = (j, k)
+    data TSSym0 :: (~>) j0123456789876543210 ((~>) k0123456789876543210 Type)
+      where
+        TSSym0KindInference :: SameKind (Apply TSSym0 arg) (TSSym1 arg) =>
+                               TSSym0 e0123456789876543210
+    type instance Apply @j0123456789876543210 @((~>) k0123456789876543210 Type) TSSym0 e0123456789876543210 = TSSym1 e0123456789876543210
+    instance SuppressUnusedWarnings TSSym0 where
+      suppressUnusedWarnings = snd ((,) TSSym0KindInference ())
+    data TSSym1 (e0123456789876543210 :: j0123456789876543210) :: (~>) k0123456789876543210 Type
+      where
+        TSSym1KindInference :: SameKind (Apply (TSSym1 e0123456789876543210) arg) (TSSym2 e0123456789876543210 arg) =>
+                               TSSym1 e0123456789876543210 e0123456789876543210
+    type instance Apply @k0123456789876543210 @Type (TSSym1 e0123456789876543210) e0123456789876543210 = TS e0123456789876543210 e0123456789876543210
+    instance SuppressUnusedWarnings (TSSym1 e0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) TSSym1KindInference ())
+    type family TSSym2 (e0123456789876543210 :: j0123456789876543210) (e0123456789876543210 :: k0123456789876543210) :: Type where
+      TSSym2 e0123456789876543210 e0123456789876543210 = TS e0123456789876543210 e0123456789876543210
+    data TFSym0 :: (~>) j0123456789876543210 ((~>) k0123456789876543210 Type)
+      where
+        TFSym0KindInference :: SameKind (Apply TFSym0 arg) (TFSym1 arg) =>
+                               TFSym0 e0123456789876543210
+    type instance Apply @j0123456789876543210 @((~>) k0123456789876543210 Type) TFSym0 e0123456789876543210 = TFSym1 e0123456789876543210
+    instance SuppressUnusedWarnings TFSym0 where
+      suppressUnusedWarnings = snd ((,) TFSym0KindInference ())
+    data TFSym1 (e0123456789876543210 :: j0123456789876543210) :: (~>) k0123456789876543210 Type
+      where
+        TFSym1KindInference :: SameKind (Apply (TFSym1 e0123456789876543210) arg) (TFSym2 e0123456789876543210 arg) =>
+                               TFSym1 e0123456789876543210 e0123456789876543210
+    type instance Apply @k0123456789876543210 @Type (TFSym1 e0123456789876543210) e0123456789876543210 = TF e0123456789876543210 e0123456789876543210
+    instance SuppressUnusedWarnings (TFSym1 e0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) TFSym1KindInference ())
+    type family TFSym2 (e0123456789876543210 :: j0123456789876543210) (e0123456789876543210 :: k0123456789876543210) :: Type where
+      TFSym2 e0123456789876543210 e0123456789876543210 = TF e0123456789876543210 e0123456789876543210
+    type MkD1Sym0 :: forall j
+                            k
+                            (a :: j)
+                            (b :: k). (~>) (Proxy a) ((~>) (Proxy b) (D1 @j @k a b))
+    data MkD1Sym0 :: (~>) (Proxy a) ((~>) (Proxy b) (D1 @j @k a b))
+      where
+        MkD1Sym0KindInference :: SameKind (Apply MkD1Sym0 arg) (MkD1Sym1 arg) =>
+                                 MkD1Sym0 a0123456789876543210
+    type instance Apply @(Proxy a) @((~>) (Proxy b) (D1 @j @k a b)) MkD1Sym0 a0123456789876543210 = MkD1Sym1 a0123456789876543210
+    instance SuppressUnusedWarnings MkD1Sym0 where
+      suppressUnusedWarnings = snd ((,) MkD1Sym0KindInference ())
+    type MkD1Sym1 :: forall j k (a :: j) (b :: k). Proxy a
+                                                   -> (~>) (Proxy b) (D1 @j @k a b)
+    data MkD1Sym1 (a0123456789876543210 :: Proxy a) :: (~>) (Proxy b) (D1 @j @k a b)
+      where
+        MkD1Sym1KindInference :: SameKind (Apply (MkD1Sym1 a0123456789876543210) arg) (MkD1Sym2 a0123456789876543210 arg) =>
+                                 MkD1Sym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @(Proxy b) @(D1 @j @k a b) (MkD1Sym1 a0123456789876543210) a0123456789876543210 = MkD1 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (MkD1Sym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) MkD1Sym1KindInference ())
+    type MkD1Sym2 :: forall j k (a :: j) (b :: k). Proxy a
+                                                   -> Proxy b -> D1 @j @k a b
+    type family MkD1Sym2 @j @k @(a :: j) @(b :: k) (a0123456789876543210 :: Proxy a) (a0123456789876543210 :: Proxy b) :: D1 @j @k a b where
+      MkD1Sym2 a0123456789876543210 a0123456789876543210 = MkD1 a0123456789876543210 a0123456789876543210
+    type MkD2Sym0 :: forall x
+                            y
+                            (a :: x)
+                            (b :: y). (~>) (Proxy a) ((~>) (Proxy b) (D2 @x @y a b))
+    data MkD2Sym0 :: (~>) (Proxy a) ((~>) (Proxy b) (D2 @x @y a b))
+      where
+        MkD2Sym0KindInference :: SameKind (Apply MkD2Sym0 arg) (MkD2Sym1 arg) =>
+                                 MkD2Sym0 a0123456789876543210
+    type instance Apply @(Proxy a) @((~>) (Proxy b) (D2 @x @y a b)) MkD2Sym0 a0123456789876543210 = MkD2Sym1 a0123456789876543210
+    instance SuppressUnusedWarnings MkD2Sym0 where
+      suppressUnusedWarnings = snd ((,) MkD2Sym0KindInference ())
+    type MkD2Sym1 :: forall x y (a :: x) (b :: y). Proxy a
+                                                   -> (~>) (Proxy b) (D2 @x @y a b)
+    data MkD2Sym1 (a0123456789876543210 :: Proxy a) :: (~>) (Proxy b) (D2 @x @y a b)
+      where
+        MkD2Sym1KindInference :: SameKind (Apply (MkD2Sym1 a0123456789876543210) arg) (MkD2Sym2 a0123456789876543210 arg) =>
+                                 MkD2Sym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @(Proxy b) @(D2 @x @y a b) (MkD2Sym1 a0123456789876543210) a0123456789876543210 = MkD2 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (MkD2Sym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) MkD2Sym1KindInference ())
+    type MkD2Sym2 :: forall x y (a :: x) (b :: y). Proxy a
+                                                   -> Proxy b -> D2 @x @y a b
+    type family MkD2Sym2 @x @y @(a :: x) @(b :: y) (a0123456789876543210 :: Proxy a) (a0123456789876543210 :: Proxy b) :: D2 @x @y a b where
+      MkD2Sym2 a0123456789876543210 a0123456789876543210 = MkD2 a0123456789876543210 a0123456789876543210
+    type MkD3Sym0 :: forall j
+                            (a :: j)
+                            k
+                            (b :: k). (~>) (Proxy a) ((~>) (Proxy b) (D3 @j a @k b))
+    data MkD3Sym0 :: (~>) (Proxy a) ((~>) (Proxy b) (D3 @j a @k b))
+      where
+        MkD3Sym0KindInference :: SameKind (Apply MkD3Sym0 arg) (MkD3Sym1 arg) =>
+                                 MkD3Sym0 a0123456789876543210
+    type instance Apply @(Proxy a) @((~>) (Proxy b) (D3 @j a @k b)) MkD3Sym0 a0123456789876543210 = MkD3Sym1 a0123456789876543210
+    instance SuppressUnusedWarnings MkD3Sym0 where
+      suppressUnusedWarnings = snd ((,) MkD3Sym0KindInference ())
+    type MkD3Sym1 :: forall j (a :: j) k (b :: k). Proxy a
+                                                   -> (~>) (Proxy b) (D3 @j a @k b)
+    data MkD3Sym1 (a0123456789876543210 :: Proxy a) :: (~>) (Proxy b) (D3 @j a @k b)
+      where
+        MkD3Sym1KindInference :: SameKind (Apply (MkD3Sym1 a0123456789876543210) arg) (MkD3Sym2 a0123456789876543210 arg) =>
+                                 MkD3Sym1 a0123456789876543210 a0123456789876543210
+    type instance Apply @(Proxy b) @(D3 @j a @k b) (MkD3Sym1 a0123456789876543210) a0123456789876543210 = MkD3 a0123456789876543210 a0123456789876543210
+    instance SuppressUnusedWarnings (MkD3Sym1 a0123456789876543210) where
+      suppressUnusedWarnings = snd ((,) MkD3Sym1KindInference ())
+    type MkD3Sym2 :: forall j (a :: j) k (b :: k). Proxy a
+                                                   -> Proxy b -> D3 @j a @k b
+    type family MkD3Sym2 @j @(a :: j) @k @(b :: k) (a0123456789876543210 :: Proxy a) (a0123456789876543210 :: Proxy b) :: D3 @j a @k b where
+      MkD3Sym2 a0123456789876543210 a0123456789876543210 = MkD3 a0123456789876543210 a0123456789876543210
+    type MkD4Sym0 :: forall (a :: Type). (~>) a (D4 @a)
+    data MkD4Sym0 :: (~>) a (D4 @a)
+      where
+        MkD4Sym0KindInference :: SameKind (Apply MkD4Sym0 arg) (MkD4Sym1 arg) =>
+                                 MkD4Sym0 a0123456789876543210
+    type instance Apply @a @(D4 @a) MkD4Sym0 a0123456789876543210 = MkD4 a0123456789876543210
+    instance SuppressUnusedWarnings MkD4Sym0 where
+      suppressUnusedWarnings = snd ((,) MkD4Sym0KindInference ())
+    type MkD4Sym1 :: forall (a :: Type). a -> D4 @a
+    type family MkD4Sym1 @(a :: Type) (a0123456789876543210 :: a) :: D4 @a where
+      MkD4Sym1 a0123456789876543210 = MkD4 a0123456789876543210
+    type Meth1Sym0 :: forall j
+                             k
+                             (a :: j)
+                             (b :: k). (~>) (Proxy a) (Proxy b)
+    data Meth1Sym0 :: (~>) (Proxy a) (Proxy b)
+      where
+        Meth1Sym0KindInference :: SameKind (Apply Meth1Sym0 arg) (Meth1Sym1 arg) =>
+                                  Meth1Sym0 a0123456789876543210
+    type instance Apply @(Proxy a) @(Proxy b) Meth1Sym0 a0123456789876543210 = Meth1 a0123456789876543210
+    instance SuppressUnusedWarnings Meth1Sym0 where
+      suppressUnusedWarnings = snd ((,) Meth1Sym0KindInference ())
+    type Meth1Sym1 :: forall j k (a :: j) (b :: k). Proxy a -> Proxy b
+    type family Meth1Sym1 @j @k @(a :: j) @(b :: k) (a0123456789876543210 :: Proxy a) :: Proxy b where
+      Meth1Sym1 a0123456789876543210 = Meth1 a0123456789876543210
+    type PC1 :: forall j k. j -> k -> Constraint
+    class PC1 @j @k (a :: j) (b :: k) where
+      type family Meth1 (arg :: Proxy a) :: Proxy b
+    type Meth2Sym0 :: forall x
+                             y
+                             (a :: x)
+                             (b :: y). (~>) (Proxy a) (Proxy b)
+    data Meth2Sym0 :: (~>) (Proxy a) (Proxy b)
+      where
+        Meth2Sym0KindInference :: SameKind (Apply Meth2Sym0 arg) (Meth2Sym1 arg) =>
+                                  Meth2Sym0 a0123456789876543210
+    type instance Apply @(Proxy a) @(Proxy b) Meth2Sym0 a0123456789876543210 = Meth2 a0123456789876543210
+    instance SuppressUnusedWarnings Meth2Sym0 where
+      suppressUnusedWarnings = snd ((,) Meth2Sym0KindInference ())
+    type Meth2Sym1 :: forall x y (a :: x) (b :: y). Proxy a -> Proxy b
+    type family Meth2Sym1 @x @y @(a :: x) @(b :: y) (a0123456789876543210 :: Proxy a) :: Proxy b where
+      Meth2Sym1 a0123456789876543210 = Meth2 a0123456789876543210
+    type PC2 :: forall j k. j -> k -> Constraint
+    class PC2 @x @y (a :: x) (b :: y) where
+      type family Meth2 (arg :: Proxy a) :: Proxy b
+    type Meth3Sym0 :: forall j
+                             (a :: j)
+                             k
+                             (b :: k). (~>) (Proxy a) (Proxy b)
+    data Meth3Sym0 :: (~>) (Proxy a) (Proxy b)
+      where
+        Meth3Sym0KindInference :: SameKind (Apply Meth3Sym0 arg) (Meth3Sym1 arg) =>
+                                  Meth3Sym0 a0123456789876543210
+    type instance Apply @(Proxy a) @(Proxy b) Meth3Sym0 a0123456789876543210 = Meth3 a0123456789876543210
+    instance SuppressUnusedWarnings Meth3Sym0 where
+      suppressUnusedWarnings = snd ((,) Meth3Sym0KindInference ())
+    type Meth3Sym1 :: forall j (a :: j) k (b :: k). Proxy a -> Proxy b
+    type family Meth3Sym1 @j @(a :: j) @k @(b :: k) (a0123456789876543210 :: Proxy a) :: Proxy b where
+      Meth3Sym1 a0123456789876543210 = Meth3 a0123456789876543210
+    type PC3 :: forall j. j -> forall k. k -> Constraint
+    class PC3 @j (a :: j) @k (b :: k) where
+      type family Meth3 (arg :: Proxy a) :: Proxy b
+    type Meth4Sym0 :: forall (a :: Type). a
+    type family Meth4Sym0 @(a :: Type) :: a where
+      Meth4Sym0 = Meth4
+    type PC4 :: forall (a :: Type). Constraint
+    class PC4 @a where
+      type family Meth4 :: a
+    type SD1 :: forall j k (a :: j) (b :: k). D1 @j @k a b -> Type
+    data SD1 :: forall j k (a :: j) (b :: k). D1 @j @k a b -> Type
+      where
+        SMkD1 :: forall j
+                        k
+                        (a :: j)
+                        (b :: k)
+                        (n :: Proxy a)
+                        (n :: Proxy b).
+                 (Sing n) -> (Sing n) -> SD1 (MkD1 n n :: D1 @j @k a b)
+    type instance Sing @(D1 @j @k a b) = SD1
+    type SD2 :: forall x y (a :: x) (b :: y). D2 @x @y a b -> Type
+    data SD2 :: forall x y (a :: x) (b :: y). D2 @x @y a b -> Type
+      where
+        SMkD2 :: forall x
+                        y
+                        (a :: x)
+                        (b :: y)
+                        (n :: Proxy a)
+                        (n :: Proxy b).
+                 (Sing n) -> (Sing n) -> SD2 (MkD2 n n :: D2 @x @y a b)
+    type instance Sing @(D2 @x @y a b) = SD2
+    type SD3 :: forall j (a :: j) k (b :: k). D3 @j a @k b -> Type
+    data SD3 :: forall j (a :: j) k (b :: k). D3 @j a @k b -> Type
+      where
+        SMkD3 :: forall j
+                        (a :: j)
+                        k
+                        (b :: k)
+                        (n :: Proxy a)
+                        (n :: Proxy b).
+                 (Sing n) -> (Sing n) -> SD3 (MkD3 n n :: D3 @j a @k b)
+    type instance Sing @(D3 @j a @k b) = SD3
+    type SD4 :: forall (a :: Type). D4 @a -> Type
+    data SD4 :: forall (a :: Type). D4 @a -> Type
+      where
+        SMkD4 :: forall (a :: Type) (n :: a).
+                 (Sing n) -> SD4 (MkD4 n :: D4 @a)
+    type instance Sing @(D4 @a) = SD4
+    class SC1 @j @k (a :: j) (b :: k) where
+      sMeth1 ::
+        (forall (t :: Proxy a).
+         Sing t -> Sing (Meth1 t :: Proxy b) :: Type)
+    class SC2 @x @y (a :: x) (b :: y) where
+      sMeth2 ::
+        (forall (t :: Proxy a).
+         Sing t -> Sing (Meth2 t :: Proxy b) :: Type)
+    class SC3 @j (a :: j) @k (b :: k) where
+      sMeth3 ::
+        (forall (t :: Proxy a).
+         Sing t -> Sing (Meth3 t :: Proxy b) :: Type)
+    class SC4 @a where
+      sMeth4 :: (Sing (Meth4 :: a) :: Type)
+    instance (SingI n, SingI n) =>
+             SingI (MkD1 (n :: Proxy a) (n :: Proxy b)) where
+      sing = SMkD1 sing sing
+    instance SingI n => SingI1 (MkD1 (n :: Proxy a)) where
+      liftSing = SMkD1 sing
+    instance SingI2 MkD1 where
+      liftSing2 = SMkD1
+    instance SingI (MkD1Sym0 :: (~>) (Proxy a) ((~>) (Proxy b) (D1 @j @k a b))) where
+      sing = singFun2 @MkD1Sym0 SMkD1
+    instance SingI d =>
+             SingI (MkD1Sym1 (d :: Proxy a) :: (~>) (Proxy b) (D1 @j @k a b)) where
+      sing = singFun1 @(MkD1Sym1 (d :: Proxy a)) (SMkD1 (sing @d))
+    instance SingI1 (MkD1Sym1 :: Proxy a
+                                 -> (~>) (Proxy b) (D1 @j @k a b)) where
+      liftSing (s :: Sing (d :: Proxy a))
+        = singFun1 @(MkD1Sym1 (d :: Proxy a)) (SMkD1 s)
+    instance (SingI n, SingI n) =>
+             SingI (MkD2 (n :: Proxy a) (n :: Proxy b)) where
+      sing = SMkD2 sing sing
+    instance SingI n => SingI1 (MkD2 (n :: Proxy a)) where
+      liftSing = SMkD2 sing
+    instance SingI2 MkD2 where
+      liftSing2 = SMkD2
+    instance SingI (MkD2Sym0 :: (~>) (Proxy a) ((~>) (Proxy b) (D2 @x @y a b))) where
+      sing = singFun2 @MkD2Sym0 SMkD2
+    instance SingI d =>
+             SingI (MkD2Sym1 (d :: Proxy a) :: (~>) (Proxy b) (D2 @x @y a b)) where
+      sing = singFun1 @(MkD2Sym1 (d :: Proxy a)) (SMkD2 (sing @d))
+    instance SingI1 (MkD2Sym1 :: Proxy a
+                                 -> (~>) (Proxy b) (D2 @x @y a b)) where
+      liftSing (s :: Sing (d :: Proxy a))
+        = singFun1 @(MkD2Sym1 (d :: Proxy a)) (SMkD2 s)
+    instance (SingI n, SingI n) =>
+             SingI (MkD3 (n :: Proxy a) (n :: Proxy b)) where
+      sing = SMkD3 sing sing
+    instance SingI n => SingI1 (MkD3 (n :: Proxy a)) where
+      liftSing = SMkD3 sing
+    instance SingI2 MkD3 where
+      liftSing2 = SMkD3
+    instance SingI (MkD3Sym0 :: (~>) (Proxy a) ((~>) (Proxy b) (D3 @j a @k b))) where
+      sing = singFun2 @MkD3Sym0 SMkD3
+    instance SingI d =>
+             SingI (MkD3Sym1 (d :: Proxy a) :: (~>) (Proxy b) (D3 @j a @k b)) where
+      sing = singFun1 @(MkD3Sym1 (d :: Proxy a)) (SMkD3 (sing @d))
+    instance SingI1 (MkD3Sym1 :: Proxy a
+                                 -> (~>) (Proxy b) (D3 @j a @k b)) where
+      liftSing (s :: Sing (d :: Proxy a))
+        = singFun1 @(MkD3Sym1 (d :: Proxy a)) (SMkD3 s)
+    instance SingI n => SingI (MkD4 (n :: a)) where
+      sing = SMkD4 sing
+    instance SingI1 MkD4 where
+      liftSing = SMkD4
+    instance SingI (MkD4Sym0 :: (~>) a (D4 @a)) where
+      sing = singFun1 @MkD4Sym0 SMkD4
+    type SC1 :: forall j k. j -> k -> Constraint
+    instance SC1 @j @k a b =>
+             SingI (Meth1Sym0 :: (~>) (Proxy a) (Proxy b)) where
+      sing = singFun1 @Meth1Sym0 sMeth1
+    type SC2 :: forall j k. j -> k -> Constraint
+    instance SC2 @x @y a b =>
+             SingI (Meth2Sym0 :: (~>) (Proxy a) (Proxy b)) where
+      sing = singFun1 @Meth2Sym0 sMeth2
+    type SC3 :: forall j. j -> forall k. k -> Constraint
+    instance SC3 @j a @k b =>
+             SingI (Meth3Sym0 :: (~>) (Proxy a) (Proxy b)) where
+      sing = singFun1 @Meth3Sym0 sMeth3
+    type SC4 :: forall (a :: Type). Constraint
diff --git a/tests/compile-and-dump/Singletons/TypeAbstractions.hs b/tests/compile-and-dump/Singletons/TypeAbstractions.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/TypeAbstractions.hs
@@ -0,0 +1,46 @@
+module TypeAbstractions where
+
+import Data.Kind
+import Data.Proxy
+import Data.Proxy.Singletons
+import Data.Singletons.Base.TH
+import Data.Singletons.TH.Options
+import Prelude.Singletons
+
+$(withOptions defaultOptions{genSingKindInsts = False} $
+  singletons [d|
+  type D1 :: forall j k. j -> k -> Type
+  data D1 @j @k (a :: j) (b :: k) = MkD1 (Proxy a) (Proxy b)
+
+  type D2 :: forall j k. j -> k -> Type
+  data D2 @x @y (a :: x) (b :: y) = MkD2 (Proxy a) (Proxy b)
+
+  type D3 :: forall j. j -> forall k. k -> Type
+  data D3 @j (a :: j) @k (b :: k) = MkD3 (Proxy a) (Proxy b)
+
+  type D4 :: forall (a :: Type). Type
+  data D4 @a = MkD4 a
+
+  type C1 :: forall j k. j -> k -> Constraint
+  class C1 @j @k (a :: j) (b :: k) where
+    meth1 :: Proxy a -> Proxy b
+
+  type C2 :: forall j k. j -> k -> Constraint
+  class C2 @x @y (a :: x) (b :: y) where
+    meth2 :: Proxy a -> Proxy b
+
+  type C3 :: forall j. j -> forall k. k -> Constraint
+  class C3 @j (a :: j) @k (b :: k) where
+    meth3 :: Proxy a -> Proxy b
+
+  type C4 :: forall (a :: Type). Constraint
+  class C4 @a where
+    meth4 :: a
+
+  type TF :: forall j. j -> forall k. k -> Type
+  type family TF @j (a :: j) @k (b :: k) where
+    TF @j _ @k _ = (j, k)
+
+  type TS :: forall j. j -> forall k. k -> Type
+  type TS @j (a :: j) @k (b :: k) = (j, k)
+  |])
diff --git a/tests/compile-and-dump/Singletons/Undef.golden b/tests/compile-and-dump/Singletons/Undef.golden
--- a/tests/compile-and-dump/Singletons/Undef.golden
+++ b/tests/compile-and-dump/Singletons/Undef.golden
@@ -14,9 +14,9 @@
       where
         BarSym0KindInference :: SameKind (Apply BarSym0 arg) (BarSym1 arg) =>
                                 BarSym0 a0123456789876543210
-    type instance Apply BarSym0 a0123456789876543210 = Bar a0123456789876543210
+    type instance Apply @Bool @Bool BarSym0 a0123456789876543210 = Bar a0123456789876543210
     instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) BarSym0KindInference ())
     type BarSym1 :: Bool -> Bool
     type family BarSym1 (a0123456789876543210 :: Bool) :: Bool where
       BarSym1 a0123456789876543210 = Bar a0123456789876543210
@@ -25,9 +25,9 @@
       where
         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>
                                 FooSym0 a0123456789876543210
-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210
+    type instance Apply @Bool @Bool FooSym0 a0123456789876543210 = Foo a0123456789876543210
     instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())
+      suppressUnusedWarnings = snd ((,) FooSym0KindInference ())
     type FooSym1 :: Bool -> Bool
     type family FooSym1 (a0123456789876543210 :: Bool) :: Bool where
       FooSym1 a0123456789876543210 = Foo a0123456789876543210
@@ -38,14 +38,16 @@
     type family Foo (a :: Bool) :: Bool where
       Foo a_0123456789876543210 = Apply UndefinedSym0 a_0123456789876543210
     sBar ::
-      forall (t :: Bool). Sing t -> Sing (Apply BarSym0 t :: Bool)
+      (forall (t :: Bool). Sing t -> Sing (Bar t :: Bool) :: Type)
     sFoo ::
-      forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)
+      (forall (t :: Bool). Sing t -> Sing (Foo t :: Bool) :: Type)
     sBar (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = (sError (sing :: Sing "urk")) sA_0123456789876543210
+      = applySing
+          (applySing (singFun1 @ErrorSym0 sError) (sing :: Sing "urk"))
+          sA_0123456789876543210
     sFoo (sA_0123456789876543210 :: Sing a_0123456789876543210)
-      = sUndefined sA_0123456789876543210
+      = applySing sUndefined sA_0123456789876543210
     instance SingI (BarSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @BarSym0) sBar
+      sing = singFun1 @BarSym0 sBar
     instance SingI (FooSym0 :: (~>) Bool Bool) where
-      sing = (singFun1 @FooSym0) sFoo
+      sing = singFun1 @FooSym0 sFoo