packages feed

singletons-base 3.1.1 → 3.5.1

raw patch · 199 files changed

Files

CHANGES.md view
@@ -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.
README.md view
@@ -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).
Setup.hs view
@@ -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
singletons-base.cabal view
@@ -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
src/Control/Applicative/Singletons.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} {-# OPTIONS_GHC -Wno-orphans #-}
src/Control/Monad/Fail/Singletons.hs view
@@ -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
src/Control/Monad/Singletons.hs view
@@ -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
src/Control/Monad/Singletons/Internal.hs view
@@ -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.+-}
src/Control/Monad/Zip/Singletons.hs view
@@ -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 #-}
src/Data/Bool/Singletons.hs view
@@ -1,6 +1,6 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Either/Singletons.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Eq/Singletons.hs view
@@ -1,6 +1,6 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Foldable/Singletons.hs view
@@ -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.
src/Data/Function/Singletons.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Functor/Compose/Singletons.hs view
@@ -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)   |])
src/Data/Functor/Const/Singletons.hs view
@@ -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)
src/Data/Functor/Identity/Singletons.hs view
@@ -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
src/Data/Functor/Product/Singletons.hs view
@@ -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)   |])
src/Data/Functor/Singletons.hs view
@@ -1,6 +1,6 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} {-# OPTIONS_GHC -Wno-orphans #-}
src/Data/Functor/Sum/Singletons.hs view
@@ -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)
src/Data/List/NonEmpty/Singletons.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} {-# OPTIONS_GHC -Wno-orphans #-}
src/Data/List/Singletons.hs view
@@ -1,5 +1,3 @@-{-# LANGUAGE ExplicitNamespaces #-}- ----------------------------------------------------------------------------- -- | -- Module      :  Data.List.Singletons
src/Data/List/Singletons/Internal.hs view
@@ -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
src/Data/List/Singletons/Internal/Disambiguation.hs view
@@ -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
src/Data/Maybe/Singletons.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Monoid/Singletons.hs view
@@ -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,
src/Data/Ord/Singletons.hs view
@@ -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)
src/Data/Ord/Singletons/Disambiguation.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Proxy/Singletons.hs view
@@ -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"
src/Data/Semigroup/Singletons.hs view
@@ -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
− src/Data/Semigroup/Singletons/Internal.hs 
@@ -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)
+ src/Data/Semigroup/Singletons/Internal/Classes.hs view
@@ -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+  |])
src/Data/Semigroup/Singletons/Internal/Disambiguation.hs view
@@ -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
+ src/Data/Semigroup/Singletons/Internal/Wrappers.hs view
@@ -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)+  |])
src/Data/Singletons/Base/Enum.hs view
@@ -1,6 +1,6 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Singletons/Base/Instances.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} {-# OPTIONS_GHC -Wno-orphans #-}
+ src/Data/Singletons/Base/PolyError.hs view
@@ -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])
src/Data/Singletons/Base/SomeSing.hs view
@@ -1,5 +1,3 @@-{-# LANGUAGE DataKinds #-}-{-# LANGUAGE GADTs #-} {-# OPTIONS_GHC -Wno-orphans #-}  -----------------------------------------------------------------------------
src/Data/Singletons/Base/TH.hs view
@@ -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
src/Data/Singletons/Base/TypeError.hs view
@@ -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
src/Data/String/Singletons.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Traversable/Singletons.hs view
@@ -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 #-}
src/Data/Tuple/Singletons.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Void/Singletons.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/GHC/Base/Singletons.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/GHC/Num/Singletons.hs view
@@ -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."
src/GHC/TypeLits/Singletons.hs view
@@ -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
src/GHC/TypeLits/Singletons/Internal.hs view
@@ -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
src/Prelude/Singletons.hs view
@@ -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,
src/Text/Show/Singletons.hs view
@@ -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.
tests/SingletonsBaseTestSuite.hs view
@@ -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
tests/SingletonsBaseTestSuiteUtils.hs view
@@ -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 }
tests/compile-and-dump/GradingClient/Database.golden view
@@ -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
tests/compile-and-dump/GradingClient/Database.hs view
@@ -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)
tests/compile-and-dump/GradingClient/Main.golden view
@@ -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)))
tests/compile-and-dump/InsertionSort/InsertionSortImp.golden view
@@ -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)
tests/compile-and-dump/Promote/Constructors.golden view
@@ -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
tests/compile-and-dump/Promote/GenDefunSymbols.golden view
@@ -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
tests/compile-and-dump/Promote/Newtypes.golden view
@@ -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
tests/compile-and-dump/Promote/Prelude.golden view
@@ -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
tests/compile-and-dump/Promote/T180.golden view
@@ -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
tests/compile-and-dump/Promote/T361.golden view
@@ -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
+ tests/compile-and-dump/Promote/T601a.golden view
@@ -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
+ tests/compile-and-dump/Promote/T601a.hs view
@@ -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+  |])
+ tests/compile-and-dump/Promote/T605.golden view
@@ -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)
+ tests/compile-and-dump/Promote/T605.hs view
@@ -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)+  |])
+ tests/compile-and-dump/Promote/T613.golden view
@@ -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
+ tests/compile-and-dump/Promote/T613.hs view
@@ -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+  |])
tests/compile-and-dump/Singletons/AsPattern.golden view
@@ -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)
tests/compile-and-dump/Singletons/BadBoundedDeriving.golden view
@@ -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|
tests/compile-and-dump/Singletons/BadEnumDeriving.golden view
@@ -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|
tests/compile-and-dump/Singletons/BoundedDeriving.golden view
@@ -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)
tests/compile-and-dump/Singletons/BoxUnBox.golden view
@@ -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
tests/compile-and-dump/Singletons/CaseExpressions.golden view
@@ -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)
tests/compile-and-dump/Singletons/Classes.golden view
@@ -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'
tests/compile-and-dump/Singletons/Classes2.golden view
@@ -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
tests/compile-and-dump/Singletons/Contains.golden view
@@ -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)
tests/compile-and-dump/Singletons/DataValues.golden view
@@ -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)
tests/compile-and-dump/Singletons/Empty.golden view
@@ -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)
tests/compile-and-dump/Singletons/EmptyShowDeriving.golden view
@@ -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))
tests/compile-and-dump/Singletons/EnumDeriving.golden view
@@ -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)
tests/compile-and-dump/Singletons/EqInstances.golden view
@@ -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
tests/compile-and-dump/Singletons/Error.golden view
@@ -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
tests/compile-and-dump/Singletons/Fixity.golden view
@@ -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)
tests/compile-and-dump/Singletons/FunDeps.golden view
@@ -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
tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden view
@@ -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
tests/compile-and-dump/Singletons/HigherOrder.golden view
@@ -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
tests/compile-and-dump/Singletons/LambdaCase.golden view
@@ -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)
tests/compile-and-dump/Singletons/Lambdas.golden view
@@ -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)
tests/compile-and-dump/Singletons/LambdasComprehensive.golden view
@@ -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))
tests/compile-and-dump/Singletons/LetStatements.golden view
@@ -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
tests/compile-and-dump/Singletons/Maybe.golden view
@@ -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
tests/compile-and-dump/Singletons/Nat.golden view
@@ -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
tests/compile-and-dump/Singletons/Natural.golden view
@@ -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
tests/compile-and-dump/Singletons/NegativeLiterals.golden view
@@ -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|   |  ^^^^^^^^^^^^^^^...+
tests/compile-and-dump/Singletons/Operators.golden view
@@ -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)
tests/compile-and-dump/Singletons/OrdDeriving.golden view
@@ -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)
tests/compile-and-dump/Singletons/OverloadedStrings.golden view
@@ -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
tests/compile-and-dump/Singletons/PatternMatching.golden view
@@ -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
tests/compile-and-dump/Singletons/PolyKinds.golden view
@@ -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
tests/compile-and-dump/Singletons/PolyKindsApp.golden view
@@ -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)
tests/compile-and-dump/Singletons/Records.golden view
@@ -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)
tests/compile-and-dump/Singletons/ReturnFunc.golden view
@@ -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)
tests/compile-and-dump/Singletons/Sections.golden view
@@ -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)
tests/compile-and-dump/Singletons/ShowDeriving.golden view
@@ -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)
tests/compile-and-dump/Singletons/StandaloneDeriving.golden view
@@ -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
tests/compile-and-dump/Singletons/Star.golden view
@@ -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)
tests/compile-and-dump/Singletons/T124.golden view
@@ -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
tests/compile-and-dump/Singletons/T136.golden view
@@ -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))
tests/compile-and-dump/Singletons/T136b.golden view
@@ -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
tests/compile-and-dump/Singletons/T145.golden view
@@ -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)
tests/compile-and-dump/Singletons/T150.golden view
@@ -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
tests/compile-and-dump/Singletons/T159.golden view
@@ -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)
tests/compile-and-dump/Singletons/T160.golden view
@@ -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    |     ^^^^+
tests/compile-and-dump/Singletons/T163.golden view
@@ -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
tests/compile-and-dump/Singletons/T166.golden view
@@ -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|   |  ^^^^^^^^^^^^^^^^^^^...+
tests/compile-and-dump/Singletons/T167.golden view
@@ -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)
tests/compile-and-dump/Singletons/T172.golden view
@@ -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)
tests/compile-and-dump/Singletons/T175.golden view
@@ -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
tests/compile-and-dump/Singletons/T176.golden view
@@ -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)
tests/compile-and-dump/Singletons/T178.golden view
@@ -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
tests/compile-and-dump/Singletons/T183.golden view
@@ -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
tests/compile-and-dump/Singletons/T184.golden view
@@ -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)
tests/compile-and-dump/Singletons/T187.golden view
@@ -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
tests/compile-and-dump/Singletons/T190.golden view
@@ -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
tests/compile-and-dump/Singletons/T197.golden view
@@ -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)
tests/compile-and-dump/Singletons/T197b.golden view
@@ -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)
tests/compile-and-dump/Singletons/T200.golden view
@@ -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
tests/compile-and-dump/Singletons/T204.golden view
@@ -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)
tests/compile-and-dump/Singletons/T209.golden view
@@ -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
tests/compile-and-dump/Singletons/T209.hs view
@@ -1,5 +1,4 @@ {-# LANGUAGE DeriveAnyClass #-}-{-# LANGUAGE DerivingStrategies #-}  module T209 where
tests/compile-and-dump/Singletons/T216.golden view
@@ -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
tests/compile-and-dump/Singletons/T229.golden view
@@ -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
tests/compile-and-dump/Singletons/T249.golden view
@@ -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
tests/compile-and-dump/Singletons/T271.golden view
@@ -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
tests/compile-and-dump/Singletons/T287.golden view
@@ -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)
tests/compile-and-dump/Singletons/T29.golden view
@@ -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
tests/compile-and-dump/Singletons/T296.golden view
@@ -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)
tests/compile-and-dump/Singletons/T297.golden view
@@ -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)
tests/compile-and-dump/Singletons/T312.golden view
@@ -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)
tests/compile-and-dump/Singletons/T313.golden view
@@ -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)
tests/compile-and-dump/Singletons/T316.golden view
@@ -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
tests/compile-and-dump/Singletons/T322.golden view
@@ -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)
tests/compile-and-dump/Singletons/T326.golden view
@@ -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)
tests/compile-and-dump/Singletons/T33.golden view
@@ -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|   |  ^^^^^^^^^^^^^^^...+
tests/compile-and-dump/Singletons/T332.golden view
@@ -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
tests/compile-and-dump/Singletons/T342.golden view
@@ -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
tests/compile-and-dump/Singletons/T342.hs view
@@ -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]
tests/compile-and-dump/Singletons/T353.golden view
@@ -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
tests/compile-and-dump/Singletons/T358.golden view
@@ -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
tests/compile-and-dump/Singletons/T367.golden view
@@ -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)
tests/compile-and-dump/Singletons/T371.golden view
@@ -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
tests/compile-and-dump/Singletons/T376.golden view
@@ -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)
tests/compile-and-dump/Singletons/T378a.golden view
@@ -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)
tests/compile-and-dump/Singletons/T378b.golden view
@@ -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
tests/compile-and-dump/Singletons/T401.golden view
@@ -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
tests/compile-and-dump/Singletons/T401b.golden view
@@ -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
tests/compile-and-dump/Singletons/T402.golden view
@@ -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
tests/compile-and-dump/Singletons/T410.golden view
@@ -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
tests/compile-and-dump/Singletons/T412.golden view
@@ -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)
tests/compile-and-dump/Singletons/T414.golden view
@@ -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
+ tests/compile-and-dump/Singletons/T433.golden view
@@ -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
+ tests/compile-and-dump/Singletons/T433.hs view
@@ -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+  -}+  |])
tests/compile-and-dump/Singletons/T443.golden view
@@ -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)
tests/compile-and-dump/Singletons/T445.golden view
@@ -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
tests/compile-and-dump/Singletons/T450.golden view
@@ -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)
tests/compile-and-dump/Singletons/T470.golden view
@@ -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|   |  ^^^^^^^^^^^^^^^...+
tests/compile-and-dump/Singletons/T480.golden view
@@ -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: _
tests/compile-and-dump/Singletons/T487.golden view
@@ -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
tests/compile-and-dump/Singletons/T489.golden view
@@ -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
tests/compile-and-dump/Singletons/T511.golden view
@@ -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|   |  ^^^^^^^^^^^^^^^...+
+ tests/compile-and-dump/Singletons/T536.golden view
@@ -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))
+ tests/compile-and-dump/Singletons/T536.hs view
@@ -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)
tests/compile-and-dump/Singletons/T54.golden view
@@ -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
+ tests/compile-and-dump/Singletons/T555.golden view
@@ -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
+ tests/compile-and-dump/Singletons/T555.hs view
@@ -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)+  |])
+ tests/compile-and-dump/Singletons/T559.golden view
@@ -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
+ tests/compile-and-dump/Singletons/T559.hs view
@@ -0,0 +1,6 @@+{-# LANGUAGE TypeData #-}+module T559 where++import Data.Singletons.TH++$(singletons [d| type data T = MkT |])
+ tests/compile-and-dump/Singletons/T563.golden view
@@ -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|+   |  ^^^^^^^^^^^^^^^^^^^...+
+ tests/compile-and-dump/Singletons/T563.hs view
@@ -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+  |])
+ tests/compile-and-dump/Singletons/T565.golden view
@@ -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
+ tests/compile-and-dump/Singletons/T565.hs view
@@ -0,0 +1,8 @@+module T565 where++import Data.Singletons.TH++$(singletons [d|+  data C a where+    D :: forall {a}. C a+  |])
+ tests/compile-and-dump/Singletons/T567.golden view
@@ -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
+ tests/compile-and-dump/Singletons/T567.hs view
@@ -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+  |])
+ tests/compile-and-dump/Singletons/T571.golden view
@@ -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)
+ tests/compile-and-dump/Singletons/T571.hs view
@@ -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+  |])
+ tests/compile-and-dump/Singletons/T581.golden view
@@ -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)
+ tests/compile-and-dump/Singletons/T581.hs view
@@ -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)+    |])
+ tests/compile-and-dump/Singletons/T582.golden view
@@ -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)
+ tests/compile-and-dump/Singletons/T582.hs view
@@ -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+  |])
+ tests/compile-and-dump/Singletons/T585.golden view
@@ -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)
+ tests/compile-and-dump/Singletons/T585.hs view
@@ -0,0 +1,8 @@+module T585 where++import Data.Singletons.TH++$(singletons [d|+  konst :: forall a {b}. a -> b -> a+  konst x _ = x+  |])
tests/compile-and-dump/Singletons/T78.golden view
@@ -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
+ tests/compile-and-dump/Singletons/T89.golden view
@@ -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
+ tests/compile-and-dump/Singletons/T89.hs view
@@ -0,0 +1,6 @@+{-# LANGUAGE OverloadedStrings #-}+module T89 where++import Data.Singletons.Base.TH++$(singletons [d|data Foo = Foo deriving (Enum)|])
tests/compile-and-dump/Singletons/TopLevelPatterns.golden view
@@ -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
+ tests/compile-and-dump/Singletons/TypeAbstractions.golden view
@@ -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
+ tests/compile-and-dump/Singletons/TypeAbstractions.hs view
@@ -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)+  |])
tests/compile-and-dump/Singletons/Undef.golden view
@@ -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