packages feed

singletons-base 3.4 → 3.5

raw patch · 145 files changed

+8174/−11544 lines, 145 filesdep +ghc-internaldep +ghc-pathsdep +ghc-primdep ~basedep ~singletons-thdep ~template-haskellsetup-changed

Dependencies added: ghc-internal, ghc-paths, ghc-prim, mtl, transformers

Dependency ranges changed: base, singletons-th, template-haskell, th-desugar

Files

CHANGES.md view
@@ -1,6 +1,86 @@ Changelog for the `singletons-base` project =========================================== +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.
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.10). For more information,+of GHC (currently GHC 9.12). 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.4-cabal-version:  1.24+version:        3.5 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.10.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.12.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.10). For more information,+    of GHC (currently GHC 9.12). For more information,     consult the @singletons@     @<https://github.com/goldfirere/singletons/blob/master/README.md README>@.     .@@ -63,22 +65,15 @@   subdir:   singletons-base   branch:   master -custom-setup-  setup-depends:-    base      >= 4.19 && < 4.21,-    Cabal     >= 3.0 && < 3.13,-    directory >= 1,-    filepath  >= 1.3- library   hs-source-dirs:     src-  build-depends:      base             >= 4.20 && < 4.21,+  build-depends:      base             >= 4.21 && < 4.22,                       pretty,                       singletons       == 3.0.*,-                      singletons-th    >= 3.4  && < 3.5,-                      template-haskell >= 2.22 && < 2.23,+                      singletons-th    >= 3.5 && < 3.6,+                      template-haskell >= 2.23 && < 2.24,                       text >= 1.2,-                      th-desugar       >= 1.17 && < 1.18+                      th-desugar       >= 1.18 && < 1.19   default-language:   GHC2021   other-extensions:   TemplateHaskell   exposed-modules:    Data.Singletons.Base.CustomStar@@ -155,13 +150,25 @@   main-is:            SingletonsBaseTestSuite.hs   other-modules:      SingletonsBaseTestSuiteUtils -  build-depends:      base >= 4.20 && < 4.21,+  build-depends:      base >= 4.21 && < 4.22,                       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/Monad/Fail/Singletons.hs view
@@ -25,6 +25,7 @@   ) where  import Control.Monad.Singletons.Internal+import Data.Kind import Data.Singletons.Base.Instances import Data.Singletons.TH @@ -49,6 +50,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/Internal.hs view
@@ -33,6 +33,7 @@  import Control.Applicative import Control.Monad+import Data.Kind import Data.List.NonEmpty (NonEmpty(..)) import Data.Singletons.Base.Instances import Data.Singletons.TH@@ -51,6 +52,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 @@ -126,6 +129,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.@@ -243,6 +248,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.@@ -352,6 +360,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@@ -386,6 +397,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      --@@ -479,3 +493,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
@@ -30,6 +30,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 )@@ -56,6 +57,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/Foldable/Singletons.hs view
@@ -127,7 +127,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@@ -215,6 +215,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 #-} @@ -578,16 +581,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/Functor/Compose/Singletons.hs view
@@ -36,65 +36,50 @@ import Data.Ord.Singletons import Data.Kind import Data.Semigroup.Singletons-import Data.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
@@ -32,73 +32,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.Classes-import Data.Singletons 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/Product/Singletons.hs view
@@ -42,46 +42,12 @@ import Data.Semigroup.Singletons hiding (SProduct(..)) import Data.Singletons.Base.Instances (SList(..), (:@#@$), NilSym0) import Data.Ord.Singletons-import Data.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)@@ -102,20 +68,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/Sum/Singletons.hs view
@@ -32,56 +32,15 @@ import Data.Foldable.Singletons hiding (Sum) import Data.Functor.Singletons import Data.Functor.Sum-import Data.Kind import Data.Ord.Singletons import Data.Semigroup.Singletons hiding (SSum(..))-import Data.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 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)
src/Data/Proxy/Singletons.hs view
@@ -32,17 +32,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.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@@ -50,27 +49,13 @@ 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
src/Data/Singletons/Base/TypeError.hs view
@@ -82,7 +82,7 @@ infixl 6 :%<>: infixl 5 :%$$: -type instance Sing = SErrorMessage+type instance Sing @PErrorMessage = SErrorMessage  instance SingKind PErrorMessage where   type Demote PErrorMessage = ErrorMessage
src/Data/Traversable/Singletons.hs view
@@ -64,7 +64,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@@ -74,7 +74,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@@ -171,6 +171,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/GHC/TypeLits/Singletons/Internal.hs view
@@ -66,7 +66,7 @@ ----------------------------------------------------------------------  -- SNat-type instance Sing = TN.SNat+type instance Sing @Natural = TN.SNat  instance TN.KnownNat n => SingI n where   sing = TN.natSing@@ -77,7 +77,7 @@   toSing n = TN.withSomeSNat n SomeSing  -- STL.Symbol-type instance Sing = TL.SSymbol+type instance Sing @TL.Symbol = TL.SSymbol  -- | An alias for the 'TL.SSymbol' pattern synonym. pattern SSym :: forall s. () => TL.KnownSymbol s => TL.SSymbol s@@ -93,7 +93,7 @@   toSing s = TL.withSomeSSymbol (T.unpack s) SomeSing  -- SChar-type instance Sing = TL.SChar+type instance Sing @Char = TL.SChar  instance TL.KnownChar c => SingI c where   sing = TL.charSing@@ -218,7 +218,7 @@   sing = singFun1 sError  -- | The singleton for 'error'.-sError :: HasCallStack => Sing (str :: TL.Symbol) -> a+sError :: forall a (str :: TL.Symbol). HasCallStack => Sing str -> Sing (Error @a str) sError sstr = error (T.unpack (fromSing sstr))  -- | The promotion of 'errorWithoutStackTrace'.@@ -229,7 +229,7 @@   sing = singFun1 sErrorWithoutStackTrace  -- | The singleton for 'errorWithoutStackTrace'.-sErrorWithoutStackTrace :: Sing (str :: TL.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'.@@ -238,7 +238,7 @@ $(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.
tests/SingletonsBaseTestSuite.hs view
@@ -150,8 +150,11 @@     , compileAndDumpStdTest "T555"     , compileAndDumpStdTest "T559"     , compileAndDumpStdTest "T563"+    , compileAndDumpStdTest "T565"     , compileAndDumpStdTest "T567"     , compileAndDumpStdTest "T571"+    , compileAndDumpStdTest "T581"+    , compileAndDumpStdTest "T582"     , compileAndDumpStdTest "T585"     , compileAndDumpStdTest "TypeAbstractions"     ],@@ -164,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
@@ -10,13 +10,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 +25,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)@@ -85,7 +86,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,3485 +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 (<>@#@$)) 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-    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 @(<>@#@$) (%<>)))-               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 (\ 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 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 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 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 where-      Let0123456789876543210Scrutinee_0123456789876543210 name name' u attrs = Apply (Apply (==@#@$) name) name'-    type family Case_0123456789876543210 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 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) :: Type)-    sOccurs ::-      (forall (t :: [AChar]) (t :: Schema).-       Sing t-       -> Sing t -> Sing (Apply (Apply OccursSym0 t) t :: Bool) :: Type)-    sDisjoint ::-      (forall (t :: Schema) (t :: Schema).-       Sing t-       -> Sing t -> Sing (Apply (Apply DisjointSym0 t) t :: Bool) :: Type)-    sAttrNotIn ::-      (forall (t :: Attribute) (t :: Schema).-       Sing t-       -> Sing t-          -> Sing (Apply (Apply AttrNotInSym0 t) t :: Bool) :: Type)-    sAppend ::-      (forall (t :: Schema) (t :: Schema).-       Sing t-       -> Sing t -> Sing (Apply (Apply AppendSym0 t) t :: Schema) :: Type)-    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.Internal.Base.id-            @(Sing (Case_0123456789876543210 name name' u attrs (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs)))-            (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 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 (\ 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 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 |]-  ======>-    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.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+    instance PShow U where+      type ShowsPrec a a a = ShowsPrec_0123456789876543210 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+    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/Main.golden view
@@ -73,13 +73,13 @@     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) :: Type)-    sGradingSchema :: (Sing (GradingSchemaSym0 :: Schema) :: Type)-    sMajorName :: (Sing (MajorNameSym0 :: [AChar]) :: Type)-    sGradeName :: (Sing (GradeNameSym0 :: [AChar]) :: Type)-    sYearName :: (Sing (YearNameSym0 :: [AChar]) :: Type)-    sFirstName :: (Sing (FirstNameSym0 :: [AChar]) :: Type)-    sLastName :: (Sing (LastNameSym0 :: [AChar]) :: Type)+    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)
tests/compile-and-dump/InsertionSort/InsertionSortImp.golden view
@@ -10,7 +10,7 @@       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 ())     type SuccSym1 :: Nat -> Nat@@ -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@@ -61,52 +62,25 @@     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+    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 n0123456789876543210 h0123456789876543210 t0123456789876543210 where-      Let0123456789876543210Scrutinee_0123456789876543210 n h t = Apply (Apply LeqSym0 n) h-    type family Case_0123456789876543210 n0123456789876543210 h0123456789876543210 t0123456789876543210 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 ())@@ -118,7 +92,7 @@       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 ())     type InsertSym1 :: Nat -> (~>) [Nat] [Nat]@@ -126,7 +100,7 @@       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 ())     type InsertSym2 :: Nat -> [Nat] -> [Nat]@@ -137,7 +111,7 @@       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 ())     type LeqSym1 :: Nat -> (~>) Nat Bool@@ -145,7 +119,7 @@       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 ())     type LeqSym2 :: Nat -> Nat -> Bool@@ -158,7 +132,7 @@     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@@ -166,15 +140,13 @@       Leq ('Succ a) ('Succ b) = Apply (Apply LeqSym0 a) b     sInsertionSort ::       (forall (t :: [Nat]).-       Sing t -> Sing (Apply InsertionSortSym0 t :: [Nat]) :: Type)+       Sing t -> Sing (InsertionSort t :: [Nat]) :: Type)     sInsert ::       (forall (t :: Nat) (t :: [Nat]).-       Sing t-       -> Sing t -> Sing (Apply (Apply InsertSym0 t) t :: [Nat]) :: Type)+       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) :: Type)+       Sing t -> Sing t -> Sing (Leq t t :: Bool) :: Type)     sInsertionSort SNil = SNil     sInsertionSort (SCons (sH :: Sing h) (sT :: Sing t))       = applySing@@ -183,23 +155,19 @@     sInsert (sN :: Sing n) 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)))-            (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))
tests/compile-and-dump/Promote/Constructors.golden view
@@ -13,7 +13,7 @@       where         (::+@#@$###) :: SameKind (Apply (:+@#@$) arg) ((:+@#@$$) arg) =>                         (:+@#@$) a0123456789876543210-    type instance Apply (:+@#@$) a0123456789876543210 = (:+@#@$$) a0123456789876543210+    type instance Apply @Foo @((~>) Foo Foo) (:+@#@$) a0123456789876543210 = (:+@#@$$) a0123456789876543210     instance SuppressUnusedWarnings (:+@#@$) where       suppressUnusedWarnings = snd ((,) (::+@#@$###) ())     type (:+@#@$$) :: Foo -> (~>) Foo Foo@@ -21,7 +21,7 @@       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 ((,) (::+@#@$$###) ())     type (:+@#@$$$) :: Foo -> Foo -> Foo@@ -32,7 +32,7 @@       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 ())     type BarSym1 :: Bar@@ -41,7 +41,7 @@       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 ())     type BarSym2 :: Bar -> Bar -> (~>) Bar ((~>) Bar ((~>) Foo Bar))@@ -49,7 +49,7 @@       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 ())     type BarSym3 :: Bar -> Bar -> Bar -> (~>) Bar ((~>) Foo Bar)@@ -57,7 +57,7 @@       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 ())     type BarSym4 :: Bar -> Bar -> Bar -> Bar -> (~>) Foo Bar@@ -65,7 +65,7 @@       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 ())     type BarSym5 :: Bar -> Bar -> Bar -> Bar -> Foo -> Bar
tests/compile-and-dump/Promote/GenDefunSymbols.golden view
@@ -7,7 +7,7 @@       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 ())@@ -17,7 +17,7 @@       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 ())@@ -33,7 +33,7 @@       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 ())@@ -45,7 +45,7 @@       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 ((,) (::+@#@$###) ())@@ -54,7 +54,7 @@       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 ((,) (::+@#@$$###) ())
tests/compile-and-dump/Promote/Newtypes.golden view
@@ -14,7 +14,7 @@       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 ())     type FooSym1 :: Nat -> Foo@@ -25,7 +25,7 @@       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 ())     type BarSym1 :: Nat -> Bar@@ -36,7 +36,7 @@       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 ())     type UnBarSym1 :: Bar -> Nat@@ -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,7 +9,7 @@       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 ())     type OddSym1 :: Natural -> Bool
tests/compile-and-dump/Promote/T180.golden view
@@ -13,7 +13,7 @@       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 ())     type X1Sym1 :: Symbol -> X@@ -24,7 +24,7 @@       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 ())     type X2Sym1 :: Symbol -> X@@ -34,7 +34,7 @@       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 ())     type family ZSym1 a0123456789876543210 where@@ -44,7 +44,7 @@       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 ())     type YSym1 :: X -> Symbol
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-    type family ProxySym0 @k @(t :: k) :: Proxy t 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,7 +16,7 @@       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 ())     type FSym1 :: Proxy 1 -> Proxy 2
+ 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
@@ -39,7 +39,7 @@       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 ())     type BazSym1 :: Nat -> (~>) Nat ((~>) Nat Baz)@@ -47,7 +47,7 @@       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 ())     type BazSym2 :: Nat -> Nat -> (~>) Nat Baz@@ -55,7 +55,7 @@       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 ())     type BazSym3 :: Nat -> Nat -> Nat -> Baz@@ -65,108 +65,28 @@       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 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 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 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 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 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@@ -178,7 +98,7 @@       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 ())     type FooSym1 :: [Nat] -> [Nat]@@ -189,7 +109,8 @@       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 ())     type TupSym1 :: (Nat, Nat) -> (Nat, Nat)@@ -201,7 +122,7 @@       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 ())     type Baz_Sym1 :: Maybe Baz -> Maybe Baz@@ -212,7 +133,7 @@       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 ())     type BarSym1 :: Maybe Nat -> Maybe Nat@@ -223,7 +144,7 @@       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 ())     type MaybePlusSym1 :: Maybe Nat -> Maybe Nat@@ -232,50 +153,48 @@     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]) :: Type)+      (forall (t :: [Nat]). Sing t -> Sing (Foo t :: [Nat]) :: Type)     sTup ::       (forall (t :: (Nat, Nat)).-       Sing t -> Sing (Apply TupSym0 t :: (Nat, Nat)) :: Type)+       Sing t -> Sing (Tup t :: (Nat, Nat)) :: Type)     sBaz_ ::       (forall (t :: Maybe Baz).-       Sing t -> Sing (Apply Baz_Sym0 t :: Maybe Baz) :: Type)+       Sing t -> Sing (Baz_ t :: Maybe Baz) :: Type)     sBar ::       (forall (t :: Maybe Nat).-       Sing t -> Sing (Apply BarSym0 t :: Maybe Nat) :: Type)+       Sing t -> Sing (Bar t :: Maybe Nat) :: Type)     sMaybePlus ::       (forall (t :: Maybe Nat).-       Sing t -> Sing (Apply MaybePlusSym0 t :: Maybe Nat) :: Type)+       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)@@ -287,7 +206,7 @@                     (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)@@ -300,7 +219,7 @@                (sWild_0123456789876543210 :: Sing wild_0123456789876543210))       = let           sP ::-            Sing @_ (Let0123456789876543210PSym2 wild_0123456789876543210 wild_0123456789876543210)+            Sing @_ (Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210)           sP             = applySing                 (applySing@@ -309,7 +228,7 @@         in sP     sBaz_ SNothing       = let-          sP :: Sing @_ Let0123456789876543210PSym0+          sP :: Sing @_ Let0123456789876543210P           sP = SNothing         in sP     sBaz_@@ -318,7 +237,7 @@                    (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)@@ -331,8 +250,7 @@     sBar       (SJust (sWild_0123456789876543210 :: Sing wild_0123456789876543210))       = let-          sX ::-            Sing @_ (Let0123456789876543210XSym1 wild_0123456789876543210)+          sX :: Sing @_ (Let0123456789876543210X wild_0123456789876543210)           sX = applySing (singFun1 @JustSym0 SJust) sWild_0123456789876543210         in sX     sBar SNothing = SNothing@@ -346,7 +264,7 @@              sN)     sMaybePlus SNothing       = let-          sP :: Sing @_ Let0123456789876543210PSym0+          sP :: Sing @_ Let0123456789876543210P           sP = SNothing         in sP     instance SingI (FooSym0 :: (~>) [Nat] [Nat]) where@@ -368,13 +286,10 @@       type Demote Baz = Baz       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
tests/compile-and-dump/Singletons/BoundedDeriving.golden view
@@ -54,7 +54,7 @@       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 ())     type Foo3Sym1 :: forall a. a -> Foo3 a@@ -71,7 +71,7 @@       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 ())     type PairSym1 :: Bool -> (~>) Bool Pair@@ -79,7 +79,7 @@       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 ())     type PairSym2 :: Bool -> Bool -> Pair@@ -88,78 +88,48 @@     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 MinBound = MinBound_0123456789876543210+      type MaxBound = MaxBound_0123456789876543210+    type MinBound_0123456789876543210 :: forall a. Foo3 a     type family MinBound_0123456789876543210 @a :: Foo3 a where-      MinBound_0123456789876543210 = Apply Foo3Sym0 MinBoundSym0-    type MinBound_0123456789876543210Sym0 :: Foo3 a-    type family MinBound_0123456789876543210Sym0 @a :: Foo3 a where-      MinBound_0123456789876543210Sym0 = MinBound_0123456789876543210-    type MaxBound_0123456789876543210 :: Foo3 a+      MinBound_0123456789876543210 @a = Apply Foo3Sym0 MinBoundSym0+    type MaxBound_0123456789876543210 :: forall a. Foo3 a     type family MaxBound_0123456789876543210 @a :: Foo3 a where-      MaxBound_0123456789876543210 = Apply Foo3Sym0 MaxBoundSym0-    type MaxBound_0123456789876543210Sym0 :: Foo3 a-    type family MaxBound_0123456789876543210Sym0 @a :: Foo3 a where-      MaxBound_0123456789876543210Sym0 = MaxBound_0123456789876543210+      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 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 = Foo41Sym0-    type MinBound_0123456789876543210Sym0 :: Foo4 a b-    type family MinBound_0123456789876543210Sym0 @a @b :: Foo4 a b where-      MinBound_0123456789876543210Sym0 = MinBound_0123456789876543210-    type MaxBound_0123456789876543210 :: Foo4 a b+      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 = Foo42Sym0-    type MaxBound_0123456789876543210Sym0 :: Foo4 a b-    type family MaxBound_0123456789876543210Sym0 @a @b :: Foo4 a b where-      MaxBound_0123456789876543210Sym0 = MaxBound_0123456789876543210+      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@@ -194,7 +164,8 @@       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 b)@@ -215,33 +186,21 @@       type Demote Pair = Pair       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     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
tests/compile-and-dump/Singletons/BoxUnBox.golden view
@@ -13,7 +13,7 @@       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 ())     type FBoxSym1 :: forall a. a -> Box a@@ -24,7 +24,7 @@       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 ())     type UnBoxSym1 :: Box a -> a@@ -34,8 +34,7 @@     type family UnBox @a (a :: Box a) :: a where       UnBox (FBox a) = a     sUnBox ::-      (forall (t :: Box a).-       Sing t -> Sing (Apply UnBoxSym0 t :: a) :: Type)+      (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@@ -47,7 +46,8 @@       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
tests/compile-and-dump/Singletons/CaseExpressions.golden view
@@ -37,122 +37,89 @@                in z     foo5 :: a -> a     foo5 x = case x of y -> (\ _ -> x) y-    type family Case_0123456789876543210 arg_01234567898765432100123456789876543210 y0123456789876543210 x0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 y x _ = x-    type family Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 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-      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-      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 x0123456789876543210 t where-      Case_0123456789876543210 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 y) x) y-    data Let0123456789876543210ZSym0 a0123456789876543210+    type family LamCases_0123456789876543210 y0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where+      LamCases_0123456789876543210 y x _ = x+    data LamCases_0123456789876543210Sym0 y0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_01234567898765432100123456789876543210       where-        Let0123456789876543210ZSym0KindInference :: SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>-                                                    Let0123456789876543210ZSym0 a0123456789876543210-    type instance Apply Let0123456789876543210ZSym0 a0123456789876543210 = Let0123456789876543210ZSym1 a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 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 ((,) Let0123456789876543210ZSym0KindInference ())-    data Let0123456789876543210ZSym1 a0123456789876543210 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-        Let0123456789876543210ZSym1KindInference :: SameKind (Apply (Let0123456789876543210ZSym1 a0123456789876543210) arg) (Let0123456789876543210ZSym2 a0123456789876543210 arg) =>-                                                    Let0123456789876543210ZSym1 a0123456789876543210 y0123456789876543210-    type instance Apply (Let0123456789876543210ZSym1 a0123456789876543210) y0123456789876543210 = Let0123456789876543210ZSym2 a0123456789876543210 y0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210ZSym1 a0123456789876543210) 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 ((,) Let0123456789876543210ZSym1KindInference ())-    data Let0123456789876543210ZSym2 a0123456789876543210 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-        Let0123456789876543210ZSym2KindInference :: SameKind (Apply (Let0123456789876543210ZSym2 a0123456789876543210 y0123456789876543210) arg) (Let0123456789876543210ZSym3 a0123456789876543210 y0123456789876543210 arg) =>-                                                    Let0123456789876543210ZSym2 a0123456789876543210 y0123456789876543210 x0123456789876543210-    type instance Apply (Let0123456789876543210ZSym2 a0123456789876543210 y0123456789876543210) x0123456789876543210 = Let0123456789876543210Z a0123456789876543210 y0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210ZSym2 a0123456789876543210 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 ((,) Let0123456789876543210ZSym2KindInference ())-    type family Let0123456789876543210ZSym3 a0123456789876543210 y0123456789876543210 x0123456789876543210 :: a0123456789876543210 where-      Let0123456789876543210ZSym3 a0123456789876543210 y0123456789876543210 x0123456789876543210 = Let0123456789876543210Z a0123456789876543210 y0123456789876543210 x0123456789876543210-    type family Let0123456789876543210Z a0123456789876543210 y0123456789876543210 x0123456789876543210 :: a0123456789876543210 where-      Let0123456789876543210Z a y x = y-    type family Case_0123456789876543210 a0123456789876543210 x0123456789876543210 t where-      Case_0123456789876543210 a x y = Let0123456789876543210ZSym3 a 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 a0123456789876543210 b0123456789876543210 where-      Let0123456789876543210Scrutinee_0123456789876543210 a b = Apply (Apply Tuple2Sym0 a) b-    type family Case_0123456789876543210 a0123456789876543210 b0123456789876543210 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 d0123456789876543210 where-      Let0123456789876543210Scrutinee_0123456789876543210 d = Apply JustSym0 d-    type family Case_0123456789876543210 d0123456789876543210 t where-      Case_0123456789876543210 d ('Just y) = y-    type family Case_0123456789876543210 d0123456789876543210 x0123456789876543210 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 ())     type Foo5Sym1 :: a -> a@@ -163,7 +130,7 @@       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 ())     type Foo4Sym1 :: forall a. a -> a@@ -174,7 +141,7 @@       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 ())     type Foo3Sym1 :: a -> (~>) b a@@ -182,7 +149,7 @@       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 ())     type Foo3Sym2 :: a -> b -> a@@ -193,7 +160,7 @@       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 ())     type Foo2Sym1 :: a -> (~>) (Maybe a) a@@ -201,7 +168,7 @@       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 ())     type Foo2Sym2 :: a -> Maybe a -> a@@ -212,7 +179,7 @@       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 ())     type Foo1Sym1 :: a -> (~>) (Maybe a) a@@ -220,7 +187,7 @@       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 ())     type Foo1Sym2 :: a -> Maybe a -> a@@ -228,82 +195,71 @@       Foo1Sym2 a0123456789876543210 a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210     type Foo5 :: a -> a     type family Foo5 @a (a :: a) :: a where-      Foo5 x = Case_0123456789876543210 x x+      Foo5 x = Apply (LamCases_0123456789876543210Sym0 x) x     type Foo4 :: forall a. a -> a     type family Foo4 @a (a :: a) :: a where-      Foo4 @a (x :: a) = Case_0123456789876543210 a x x+      Foo4 @a (x :: a) = Apply (LamCases_0123456789876543210Sym0 a x) x     type Foo3 :: a -> b -> a     type family Foo3 @a @b (a :: a) (a :: b) :: a where-      Foo3 a b = Case_0123456789876543210 a b (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a b)+      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) (a :: Maybe a) :: a where-      Foo2 d _ = Case_0123456789876543210 d (Let0123456789876543210Scrutinee_0123456789876543210Sym1 d)+      Foo2 d _ = Apply (LamCases_0123456789876543210Sym0 d) (Apply JustSym0 d)     type Foo1 :: a -> Maybe a -> a     type family Foo1 @a (a :: a) (a :: Maybe a) :: a where-      Foo1 d x = Case_0123456789876543210 d x x-    sFoo5 ::-      (forall (t :: a). Sing t -> Sing (Apply Foo5Sym0 t :: a) :: Type)-    sFoo4 :: forall a (t :: a). Sing t -> Sing (Apply Foo4Sym0 t :: a)+      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 (t :: a) (t :: b).-       Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a) :: Type)+       Sing t -> Sing t -> Sing (Foo3 t t :: a) :: Type)     sFoo2 ::       (forall (t :: a) (t :: Maybe a).-       Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) :: Type)+       Sing t -> Sing t -> Sing (Foo2 t t :: a) :: Type)     sFoo1 ::       (forall (t :: a) (t :: Maybe a).-       Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) :: Type)+       Sing t -> Sing t -> Sing (Foo1 t t :: a) :: Type)     sFoo5 (sX :: Sing x)-      = id-          @(Sing (Case_0123456789876543210 x x))-          (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 a x x))-          (case sX of-             (sY :: Sing y)-               -> let-                    sZ :: (Sing (Let0123456789876543210ZSym3 a y x :: a) :: Type)-                    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)))-            (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)))-            (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))-          (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     instance SingI (Foo4Sym0 :: (~>) a a) where
tests/compile-and-dump/Singletons/Classes.golden view
@@ -76,7 +76,7 @@       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 ())     type FooCompareSym1 :: Foo -> (~>) Foo Ordering@@ -84,7 +84,7 @@       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 ())     type FooCompareSym2 :: Foo -> Foo -> Ordering@@ -95,7 +95,7 @@       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 ())     type ConstSym1 :: a -> (~>) b a@@ -103,7 +103,7 @@       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 ())     type ConstSym2 :: a -> b -> a@@ -123,7 +123,7 @@       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 ())     type MycompareSym1 :: forall a. a -> (~>) a Ordering@@ -131,7 +131,7 @@       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 ())     type MycompareSym2 :: forall a. a -> a -> Ordering@@ -142,170 +142,62 @@       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 <=>@#@$+    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 <=>@#@$$+    infix 4 type <=>@#@$$     type (<=>@#@$$$) :: forall a. a -> a -> Ordering     type family (<=>@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ordering where       (<=>@#@$$$) a0123456789876543210 a0123456789876543210 = (<=>) a0123456789876543210 a0123456789876543210-    infix 4 <=>@#@$$$-    type TFHelper_0123456789876543210 :: a -> a -> Ordering+    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_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 @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ordering where-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+      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) :: Type)+       Sing t -> Sing t -> Sing (FooCompare t t :: Ordering) :: Type)     sConst ::       (forall (t :: a) (t :: b).-       Sing t-       -> Sing t -> Sing (Apply (Apply ConstSym0 t) t :: a) :: Type)+       Sing t -> Sing t -> Sing (Const t t :: a) :: Type)     sFooCompare SA SA = SEQ     sFooCompare SA SB = SLT     sFooCompare SB SB = SGT@@ -352,22 +244,15 @@     class SMyOrd a where       sMycompare ::         (forall (t :: a) (t :: a).-         Sing t-         -> Sing t-            -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) :: Type)+         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) :: Type)-      infix 4 %<=>+         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) :: Type)+                 (((<=>) 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)@@ -376,31 +261,16 @@                (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) :: Type)       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     instance SMyOrd () where-      sMycompare ::-        (forall (t :: ()) (t :: ()).-         Sing t-         -> Sing t-            -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) :: Type)       sMycompare _ (sA_0123456789876543210 :: Sing a_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) :: Type)       sMycompare         (sA_0123456789876543210 :: Sing a_0123456789876543210)         (sA_0123456789876543210 :: Sing a_0123456789876543210)@@ -409,11 +279,6 @@                (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@@ -470,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'@@ -546,7 +368,7 @@       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 ())     type Succ'Sym1 :: Nat' -> Nat'@@ -558,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')@@ -593,14 +393,9 @@       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
tests/compile-and-dump/Singletons/Classes2.golden view
@@ -22,7 +22,7 @@       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 ())     type SuccFooSym1 :: NatFoo -> NatFoo@@ -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,14 +48,9 @@       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
tests/compile-and-dump/Singletons/Contains.golden view
@@ -12,7 +12,7 @@       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 ())     type ContainsSym1 :: a -> (~>) [a] Bool@@ -20,7 +20,7 @@       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 ())     type ContainsSym2 :: a -> [a] -> Bool@@ -32,9 +32,7 @@       Contains elt ('(:) h t) = Apply (Apply (||@#@$) (Apply (Apply (==@#@$) elt) h)) (Apply (Apply ContainsSym0 elt) t)     sContains ::       (forall (t :: a) (t :: [a]).-       SEq a =>-       Sing t-       -> Sing t -> Sing (Apply (Apply ContainsSym0 t) t :: Bool) :: Type)+       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
tests/compile-and-dump/Singletons/DataValues.golden view
@@ -21,7 +21,7 @@       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 ())     type PairSym1 :: forall a b. a -> (~>) b (Pair a b)@@ -29,7 +29,7 @@       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 ())     type PairSym2 :: forall a b. a -> b -> Pair a b@@ -51,49 +51,17 @@       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 ShowsPrec_0123456789876543210 :: forall a+                                                 b. GHC.Num.Natural.Natural+                                                    -> Pair a b -> Symbol -> Symbol     type family ShowsPrec_0123456789876543210 @a @b (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 @a @b (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Pair a b) (a0123456789876543210 :: Symbol) :: Symbol where-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+      ShowsPrec_0123456789876543210 @a @b (p_0123456789876543210 :: GHC.Num.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)@@ -139,17 +107,9 @@       type Demote (Pair a b) = Pair (Demote a) (Demote 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)
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,39 @@   ======>     data Foo     deriving instance Show Foo-    type family Case_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t where+    type family LamCases_0123456789876543210 (v_01234567898765432100123456789876543210 :: Foo) (a_01234567898765432100123456789876543210 :: GHC.Types.Symbol) a_0123456789876543210 where+    data LamCases_0123456789876543210Sym0 (v_01234567898765432100123456789876543210 :: Foo) (a_01234567898765432100123456789876543210 :: GHC.Types.Symbol) a_01234567898765432100123456789876543210+      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 ((,) LamCases_0123456789876543210Sym0KindInference ())+    type family LamCases_0123456789876543210Sym1 (v_01234567898765432100123456789876543210 :: Foo) (a_01234567898765432100123456789876543210 :: GHC.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.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-      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-                                              -> 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+      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+               (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,56 @@     type Q2Sym0 :: Quux     type family Q2Sym0 :: Quux where       Q2Sym0 = Q2-    type family Case_0123456789876543210 n0123456789876543210 t where-      Case_0123456789876543210 n 'True = BumSym0-      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"-    type family Case_0123456789876543210 n0123456789876543210 t where-      Case_0123456789876543210 n 'True = BazSym0-      Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 2))-    type family Case_0123456789876543210 n0123456789876543210 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.Num.Natural.Natural) a_0123456789876543210 where+      LamCases_0123456789876543210 n 'True = BumSym0+      LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Num.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+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Num.Natural.Natural) a_01234567898765432100123456789876543210 where+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Num.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.Num.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.Num.Natural.Natural) a_01234567898765432100123456789876543210 where+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Num.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.Num.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.Num.Natural.Natural) a_01234567898765432100123456789876543210 where+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210+    type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> Foo+    type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: Foo where+      ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0))     type FromEnum_0123456789876543210 :: Foo -> GHC.Num.Natural.Natural     type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Num.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,42 +100,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)@@ -148,76 +147,65 @@ Singletons/EnumDeriving.hs:0:0:: Splicing declarations     singEnumInstance ''Quux   ======>-    type family Case_0123456789876543210 n0123456789876543210 t where-      Case_0123456789876543210 n 'True = Q2Sym0-      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"-    type family Case_0123456789876543210 n0123456789876543210 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.Num.Natural.Natural) a_0123456789876543210 where+      LamCases_0123456789876543210 n 'True = Q2Sym0+      LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Num.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.Num.Natural.Natural) a_01234567898765432100123456789876543210 where+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Num.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.Num.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.Num.Natural.Natural) a_01234567898765432100123456789876543210 where+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210+    type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> Quux+    type family ToEnum_0123456789876543210 (a :: GHC.Num.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       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@@ -56,33 +30,7 @@     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,7 +12,7 @@       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 ())     type HeadSym1 :: [a] -> a@@ -22,9 +22,10 @@     type family Head @a (a :: [a]) :: a where       Head ('(:) a _) = a       Head '[] = Apply ErrorSym0 "head: empty list"-    sHead ::-      (forall (t :: [a]). Sing t -> Sing (Apply HeadSym0 t :: a) :: Type)+    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
tests/compile-and-dump/Singletons/Fixity.golden view
@@ -20,23 +20,23 @@       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 ====@#@$+    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 ====@#@$$+    infix 4 type ====@#@$$     type (====@#@$$$) :: a -> a -> a     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) :: a where       (====) a _ = a@@ -45,30 +45,29 @@       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 <=>@#@$+    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 <=>@#@$$+    infix 4 type <=>@#@$$     type (<=>@#@$$$) :: forall a. a -> a -> Ordering     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 (t :: a) (t :: a).-       Sing t-       -> Sing t -> Sing (Apply (Apply (====@#@$) t) t :: a) :: Type)+       Sing t -> Sing t -> Sing ((====) t t :: a) :: Type)     (%====) (sA :: Sing a) _ = sA     instance SingI ((====@#@$) :: (~>) a ((~>) a a)) where       sing = singFun2 @(====@#@$) (%====)@@ -80,10 +79,8 @@     class SMyOrd a where       (%<=>) ::         (forall (t :: a) (t :: a).-         Sing t-         -> Sing t-            -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering) :: Type)-      infix 4 %<=>+         Sing t -> Sing t -> Sing ((<=>) t t :: Ordering) :: Type)+      infix 4 data %<=>     instance SMyOrd a =>              SingI ((<=>@#@$) :: (~>) a ((~>) a Ordering)) where       sing = singFun2 @(<=>@#@$) (%<=>)
tests/compile-and-dump/Singletons/FunDeps.golden view
@@ -28,7 +28,7 @@       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 ())     type MethSym1 :: forall a. a -> a@@ -39,7 +39,7 @@       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 ())     type L2rSym1 :: forall a b. a -> b@@ -51,51 +51,19 @@     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+      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) :: Type)-      sL2r ::-        (forall (t :: a). Sing t -> Sing (Apply L2rSym0 t :: b) :: Type)+      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) :: Type)-      sL2r ::-        (forall (t :: Bool).-         Sing t -> Sing (Apply L2rSym0 t :: Natural) :: Type)       sMeth (sA_0123456789876543210 :: Sing a_0123456789876543210)         = applySing (singFun1 @NotSym0 sNot) sA_0123456789876543210       sL2r SFalse = sFromInteger (sing :: Sing 0)
tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden view
@@ -15,1317 +15,613 @@       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 @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 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 Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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 @b @x (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 @a @b @x (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: T x a) :: T x b where-      Fmap_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210-    type family Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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 @x @b (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 @a @x @b (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_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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 @m @x (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 @a @m @x (a0123456789876543210 :: (~>) a m) (a0123456789876543210 :: T x a) :: m where-      FoldMap_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = FoldMap_0123456789876543210 a0123456789876543210 a0123456789876543210-    type family Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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 @b @x (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 @a @b @x (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 @f @b @x (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 @a @f @b @x (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_01234567898765432100123456789876543210 t where-    type Fmap_0123456789876543210 :: (~>) a b -> Empty a -> Empty b-    type family Fmap_0123456789876543210 @a @b (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 @a @b (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: Empty a) :: Empty b where-      Fmap_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210-    type family Case_0123456789876543210 v_01234567898765432100123456789876543210 t where-    type TFHelper_0123456789876543210 :: a -> Empty b -> Empty a-    type family TFHelper_0123456789876543210 @a @b (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 @a @b (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 @m (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 @a @m (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_01234567898765432100123456789876543210 t where-    type Traverse_0123456789876543210 :: (~>) 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 _ 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 @a @f @b (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 {}))+    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
tests/compile-and-dump/Singletons/HigherOrder.golden view
@@ -45,7 +45,7 @@       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 ())     type LeftSym1 :: forall a b. a -> Either a b@@ -56,96 +56,84 @@       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 ())     type RightSym1 :: forall a b. b -> Either a b     type family RightSym1 @a @b (a0123456789876543210 :: b) :: Either a b where       RightSym1 a0123456789876543210 = Right a0123456789876543210-    type family Case_0123456789876543210 n0123456789876543210 b0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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 n0123456789876543210 b0123456789876543210 ns0123456789876543210 bs0123456789876543210 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 ns0123456789876543210 bs0123456789876543210 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 ())     type EtadSym1 :: [Nat] -> (~>) [Bool] [Nat]@@ -153,7 +141,7 @@       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 ())     type EtadSym2 :: [Nat] -> [Bool] -> [Nat]@@ -164,7 +152,7 @@       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 ())     type SplungeSym1 :: [Nat] -> (~>) [Bool] [Nat]@@ -172,7 +160,7 @@       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 ())     type SplungeSym2 :: [Nat] -> [Bool] -> [Nat]@@ -183,7 +171,7 @@       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 ())     type FooSym1 :: (~>) ((~>) a b) ((~>) a b)@@ -192,7 +180,7 @@       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 ())     type FooSym2 :: (~>) ((~>) a b) ((~>) a b) -> (~>) a b -> (~>) a b@@ -200,7 +188,7 @@       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 ())     type FooSym3 :: (~>) ((~>) a b) ((~>) a b) -> (~>) a b -> a -> b@@ -211,7 +199,7 @@       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 ())     type ZipWithSym1 :: (~>) a ((~>) b c) -> (~>) [a] ((~>) [b] [c])@@ -219,7 +207,7 @@       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 ())     type ZipWithSym2 :: (~>) a ((~>) b c) -> [a] -> (~>) [b] [c]@@ -227,7 +215,7 @@       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 ())     type ZipWithSym3 :: (~>) a ((~>) b c) -> [a] -> [b] -> [c]@@ -238,7 +226,7 @@       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 ())     type LiftMaybeSym1 :: (~>) a b -> (~>) (Maybe a) (Maybe b)@@ -246,7 +234,7 @@       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 ())     type LiftMaybeSym2 :: (~>) a b -> Maybe a -> Maybe b@@ -257,7 +245,7 @@       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 ())     type MapSym1 :: (~>) a b -> (~>) [a] [b]@@ -265,7 +253,7 @@       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 ())     type MapSym2 :: (~>) a b -> [a] -> [b]@@ -273,10 +261,10 @@       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 @b (a :: (~>) ((~>) a b) ((~>) a b)) (a :: (~>) a b) (a :: a) :: b where       Foo f g a = Apply (Apply f g) a@@ -296,33 +284,22 @@       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]) :: Type)+       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]) :: Type)+       Sing t -> Sing t -> Sing (Splunge t t :: [Nat]) :: Type)     sFoo ::       (forall (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) :: Type)+       Sing t -> Sing t -> Sing t -> Sing (Foo t t t :: b) :: Type)     sZipWith ::       (forall (t :: (~>) a ((~>) b c)) (t :: [a]) (t :: [b]).-       Sing t-       -> Sing t-          -> Sing t-             -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c]) :: Type)+       Sing t -> Sing t -> Sing t -> Sing (ZipWith t t t :: [c]) :: Type)     sLiftMaybe ::       (forall (t :: (~>) a b) (t :: Maybe a).-       Sing t-       -> Sing t-          -> Sing (Apply (Apply LiftMaybeSym0 t) t :: Maybe b) :: Type)+       Sing t -> Sing t -> Sing (LiftMaybe t t :: Maybe b) :: Type)     sMap ::       (forall (t :: (~>) a b) (t :: [a]).-       Sing t-       -> Sing t -> Sing (Apply (Apply MapSym0 t) t :: [b]) :: Type)+       Sing t -> Sing t -> Sing (Map t t :: [b]) :: Type)     sEtad       (sA_0123456789876543210 :: Sing a_0123456789876543210)       (sA_0123456789876543210 :: Sing a_0123456789876543210)@@ -331,18 +308,19 @@              (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))))+                   @(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)@@ -351,18 +329,19 @@              (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))))+                   @(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)@@ -497,9 +476,11 @@       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
tests/compile-and-dump/Singletons/LambdaCase.golden view
@@ -29,96 +29,50 @@           (Just d)     foo3 :: a -> b -> a     foo3 a b = (\case (p, _) -> p) (a, b)-    type family Case_0123456789876543210 x_01234567898765432100123456789876543210 a0123456789876543210 b0123456789876543210 t where-      Case_0123456789876543210 x_0123456789876543210 a b '(p, _) = p-    type family Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 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_01234567898765432100123456789876543210 d0123456789876543210 t where-      Case_0123456789876543210 x_0123456789876543210 d ('Just y) = y-      Case_0123456789876543210 x_0123456789876543210 d 'Nothing = d-    type family Lambda_0123456789876543210 d0123456789876543210 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_01234567898765432100123456789876543210 d0123456789876543210 x0123456789876543210 t where-      Case_0123456789876543210 x_0123456789876543210 d x ('Just y) = y-      Case_0123456789876543210 x_0123456789876543210 d x 'Nothing = d-    type family Lambda_0123456789876543210 d0123456789876543210 x0123456789876543210 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 ())     type Foo3Sym1 :: a -> (~>) b a@@ -126,7 +80,7 @@       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 ())     type Foo3Sym2 :: a -> b -> a@@ -137,7 +91,7 @@       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 ())     type Foo2Sym1 :: a -> (~>) (Maybe a) a@@ -145,7 +99,7 @@       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 ())     type Foo2Sym2 :: a -> Maybe a -> a@@ -156,7 +110,7 @@       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 ())     type Foo1Sym1 :: a -> (~>) (Maybe a) a@@ -164,7 +118,7 @@       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 ())     type Foo1Sym2 :: a -> Maybe a -> a@@ -172,58 +126,43 @@       Foo1Sym2 a0123456789876543210 a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210     type Foo3 :: a -> b -> a     type family Foo3 @a @b (a :: a) (a :: b) :: a where-      Foo3 a b = Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) (Apply (Apply Tuple2Sym0 a) b)+      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) (a :: Maybe a) :: a where-      Foo2 d _ = Apply (Apply Lambda_0123456789876543210Sym0 d) (Apply JustSym0 d)+      Foo2 d _ = Apply (LamCases_0123456789876543210Sym0 d) (Apply JustSym0 d)     type Foo1 :: a -> Maybe a -> a     type family Foo1 @a (a :: a) (a :: Maybe a) :: a where-      Foo1 d x = Apply (Apply (Apply Lambda_0123456789876543210Sym0 d) x) x+      Foo1 d x = Apply (LamCases_0123456789876543210Sym0 d x) x     sFoo3 ::       (forall (t :: a) (t :: b).-       Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a) :: Type)+       Sing t -> Sing t -> Sing (Foo3 t t :: a) :: Type)     sFoo2 ::       (forall (t :: a) (t :: Maybe a).-       Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) :: Type)+       Sing t -> Sing t -> Sing (Foo2 t t :: a) :: Type)     sFoo1 ::       (forall (t :: a) (t :: Maybe a).-       Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) :: Type)+       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)))+             @(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)))+             @(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)))+             @(LamCases_0123456789876543210Sym0 d x)+             (\cases+                (SJust (sY :: Sing y)) -> sY+                SNothing -> sD))           sX     instance SingI (Foo3Sym0 :: (~>) a ((~>) b a)) where       sing = singFun2 @Foo3Sym0 sFoo3
tests/compile-and-dump/Singletons/Lambdas.golden view
@@ -45,7 +45,7 @@       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 ())     type FooSym1 :: forall a b. a -> (~>) b (Foo a b)@@ -53,327 +53,154 @@       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 ())     type FooSym2 :: forall a b. a -> b -> Foo a b     type family FooSym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Foo a b where       FooSym2 a0123456789876543210 a0123456789876543210 = Foo a0123456789876543210 a0123456789876543210-    type family Case_0123456789876543210 arg_01234567898765432100123456789876543210 x0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 x (Foo a _) = a-    type family Lambda_0123456789876543210 x0123456789876543210 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_01234567898765432100123456789876543210 x0123456789876543210 y0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 x y '(_, b) = b-    type family Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 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_01234567898765432100123456789876543210 x0123456789876543210 a0123456789876543210 b0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 x a b _ = x-    type family Lambda_0123456789876543210 x0123456789876543210 a0123456789876543210 b0123456789876543210 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 a0123456789876543210 b0123456789876543210 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 x0123456789876543210 y0123456789876543210 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_01234567898765432100123456789876543210 arg_01234567898765432100123456789876543210 x0123456789876543210 y0123456789876543210 z0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210 x y z '(_,-                                                                                       _) = x-    type family Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 z0123456789876543210 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 x0123456789876543210 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_01234567898765432100123456789876543210 x0123456789876543210 y0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 x y _ = x-    type family Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 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_01234567898765432100123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 x a_0123456789876543210 _ = x-    type family Lambda_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 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_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 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 ())     type Foo8Sym1 :: Foo a b -> a@@ -384,7 +211,7 @@       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 ())     type Foo7Sym1 :: a -> (~>) b b@@ -392,7 +219,7 @@       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 ())     type Foo7Sym2 :: a -> b -> b@@ -403,7 +230,7 @@       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 ())     type Foo6Sym1 :: a -> (~>) b a@@ -411,7 +238,7 @@       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 ())     type Foo6Sym2 :: a -> b -> a@@ -422,7 +249,7 @@       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 ())     type Foo5Sym1 :: a -> (~>) b b@@ -430,7 +257,7 @@       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 ())     type Foo5Sym2 :: a -> b -> b@@ -441,7 +268,7 @@       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 ())     type Foo4Sym1 :: a -> (~>) b ((~>) c a)@@ -449,7 +276,7 @@       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 ())     type Foo4Sym2 :: a -> b -> (~>) c a@@ -457,7 +284,7 @@       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 ())     type Foo4Sym3 :: a -> b -> c -> a@@ -468,7 +295,7 @@       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 ())     type Foo3Sym1 :: a -> a@@ -479,7 +306,7 @@       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 ())     type Foo2Sym1 :: a -> (~>) b a@@ -487,7 +314,7 @@       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 ())     type Foo2Sym2 :: a -> b -> a@@ -498,7 +325,7 @@       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 ())     type Foo1Sym1 :: a -> (~>) b a@@ -506,7 +333,7 @@       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 ())     type Foo1Sym2 :: a -> b -> a@@ -517,7 +344,7 @@       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 ())     type Foo0Sym1 :: a -> (~>) b a@@ -525,7 +352,7 @@       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 ())     type Foo0Sym2 :: a -> b -> a@@ -533,155 +360,108 @@       Foo0Sym2 a0123456789876543210 a0123456789876543210 = Foo0 a0123456789876543210 a0123456789876543210     type Foo8 :: Foo a b -> a     type family Foo8 @a @b (a :: Foo a b) :: a where-      Foo8 x = Apply (Apply Lambda_0123456789876543210Sym0 x) x+      Foo8 x = Apply (LamCases_0123456789876543210Sym0 x) x     type Foo7 :: a -> b -> b     type family Foo7 @a @b (a :: a) (a :: b) :: b where-      Foo7 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) (Apply (Apply Tuple2Sym0 x) y)+      Foo7 x y = Apply (LamCases_0123456789876543210Sym0 x y) (Apply (Apply Tuple2Sym0 x) y)     type Foo6 :: a -> b -> a     type family Foo6 @a @b (a :: a) (a :: b) :: a where-      Foo6 a b = Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) a) b+      Foo6 a b = Apply (Apply (LamCases_0123456789876543210Sym0 a b) a) b     type Foo5 :: a -> b -> b     type family Foo5 @a @b (a :: a) (a :: b) :: b where-      Foo5 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y+      Foo5 x y = Apply (LamCases_0123456789876543210Sym0 x y) y     type Foo4 :: a -> b -> c -> a     type family Foo4 @a @b @c (a :: a) (a :: b) (a :: c) :: a where-      Foo4 x y z = Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) z) y) z+      Foo4 x y z = Apply (Apply (LamCases_0123456789876543210Sym0 x y z) y) z     type Foo3 :: a -> a     type family Foo3 @a (a :: a) :: a where-      Foo3 x = Apply (Apply Lambda_0123456789876543210Sym0 x) x+      Foo3 x = Apply (LamCases_0123456789876543210Sym0 x) x     type Foo2 :: a -> b -> a     type family Foo2 @a @b (a :: a) (a :: b) :: a where-      Foo2 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y+      Foo2 x y = Apply (LamCases_0123456789876543210Sym0 x y) y     type Foo1 :: a -> b -> a     type family Foo1 @a @b (a :: a) (a :: b) :: a where-      Foo1 x a_0123456789876543210 = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) a_0123456789876543210) a_0123456789876543210+      Foo1 x a_0123456789876543210 = Apply (LamCases_0123456789876543210Sym0 x a_0123456789876543210) a_0123456789876543210     type Foo0 :: a -> b -> a     type family Foo0 @a @b (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+      Foo0 a_0123456789876543210 a_0123456789876543210 = Apply (Apply (LamCases_0123456789876543210Sym0 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210) a_0123456789876543210     sFoo8 ::-      (forall (t :: Foo a b).-       Sing t -> Sing (Apply Foo8Sym0 t :: a) :: Type)+      (forall (t :: Foo a b). Sing t -> Sing (Foo8 t :: a) :: Type)     sFoo7 ::       (forall (t :: a) (t :: b).-       Sing t -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: b) :: Type)+       Sing t -> Sing t -> Sing (Foo7 t t :: b) :: Type)     sFoo6 ::       (forall (t :: a) (t :: b).-       Sing t -> Sing t -> Sing (Apply (Apply Foo6Sym0 t) t :: a) :: Type)+       Sing t -> Sing t -> Sing (Foo6 t t :: a) :: Type)     sFoo5 ::       (forall (t :: a) (t :: b).-       Sing t -> Sing t -> Sing (Apply (Apply Foo5Sym0 t) t :: b) :: Type)+       Sing t -> Sing t -> Sing (Foo5 t t :: b) :: Type)     sFoo4 ::       (forall (t :: a) (t :: b) (t :: c).-       Sing t-       -> Sing t-          -> Sing t-             -> Sing (Apply (Apply (Apply Foo4Sym0 t) t) t :: a) :: Type)-    sFoo3 ::-      (forall (t :: a). Sing t -> Sing (Apply Foo3Sym0 t :: a) :: Type)+       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 (t :: a) (t :: b).-       Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) :: Type)+       Sing t -> Sing t -> Sing (Foo2 t t :: a) :: Type)     sFoo1 ::       (forall (t :: a) (t :: b).-       Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) :: Type)+       Sing t -> Sing t -> Sing (Foo1 t t :: a) :: Type)     sFoo0 ::       (forall (t :: a) (t :: b).-       Sing t -> Sing t -> Sing (Apply (Apply Foo0Sym0 t) t :: a) :: Type)+       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)))+             @(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)))+             @(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))))+                @(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))+             @(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)))+                @(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))+             @(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)))+          (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)))+             @(LamCases_0123456789876543210Sym0 x a_0123456789876543210)+             (\cases _ -> sX))           sA_0123456789876543210     sFoo0       (sA_0123456789876543210 :: Sing a_0123456789876543210)@@ -689,9 +469,8 @@       = applySing           (applySing              (singFun2-                @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210)-                (\ sX sY-                   -> case (,) sX sY of (,) (_ :: Sing x) (_ :: Sing y) -> sX))+                @(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@@ -769,8 +548,8 @@       type Demote (Foo a b) = Foo (Demote a) (Demote 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     instance SingI n => SingI1 (Foo (n :: a)) where
tests/compile-and-dump/Singletons/LambdasComprehensive.golden view
@@ -11,18 +11,18 @@       = 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+    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@@ -34,9 +34,9 @@       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]) :: Type)-    sFoo :: (Sing (FooSym0 :: [Nat]) :: Type)+      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@@ -61,16 +61,15 @@           (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)))+                @LamCases_0123456789876543210Sym0+                (\cases+                   (sX :: Sing x)+                     -> applySing+                          (applySing+                             (applySing+                                (singFun3 @Either_Sym0 sEither_) (singFun1 @PredSym0 sPred))+                             (singFun1 @SuccSym0 SSucc))+                          sX)))           (applySing              (applySing                 (singFun2 @(:@#@$) SCons)
tests/compile-and-dump/Singletons/LetStatements.golden view
@@ -189,364 +189,206 @@     foo13_ y = y     foo14 :: Nat -> (Nat, Nat)     foo14 x = let (y, z) = (Succ x, x) in (z, y)-    type family Case_0123456789876543210 x0123456789876543210 t where-      Case_0123456789876543210 x '(_,-                                   y_0123456789876543210) = y_0123456789876543210-    type family Case_0123456789876543210 x0123456789876543210 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 x0123456789876543210 where-      Let0123456789876543210Z x = Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x)-    type family Let0123456789876543210Y x0123456789876543210 where-      Let0123456789876543210Y x = Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x)-    type family Let0123456789876543210X_0123456789876543210 x0123456789876543210 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 a0123456789876543210-      where-        Let0123456789876543210BarSym0KindInference :: SameKind (Apply Let0123456789876543210BarSym0 arg) (Let0123456789876543210BarSym1 arg) =>-                                                      Let0123456789876543210BarSym0 a0123456789876543210-    type instance Apply Let0123456789876543210BarSym0 a0123456789876543210 = Let0123456789876543210BarSym1 a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210BarSym0 where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210BarSym0KindInference ())-    data Let0123456789876543210BarSym1 a0123456789876543210 x0123456789876543210-      where-        Let0123456789876543210BarSym1KindInference :: SameKind (Apply (Let0123456789876543210BarSym1 a0123456789876543210) arg) (Let0123456789876543210BarSym2 a0123456789876543210 arg) =>-                                                      Let0123456789876543210BarSym1 a0123456789876543210 x0123456789876543210-    type instance Apply (Let0123456789876543210BarSym1 a0123456789876543210) x0123456789876543210 = Let0123456789876543210Bar a0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210BarSym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210BarSym1KindInference ())-    type family Let0123456789876543210BarSym2 a0123456789876543210 x0123456789876543210 :: a0123456789876543210 where-      Let0123456789876543210BarSym2 a0123456789876543210 x0123456789876543210 = Let0123456789876543210Bar a0123456789876543210 x0123456789876543210-    type family Let0123456789876543210Bar a0123456789876543210 x0123456789876543210 :: a0123456789876543210 where+    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+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) (x0123456789876543210 :: Nat) :: (~>) Nat ((~>) Nat Nat)       where-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: SameKind (Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>-                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210-    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210-    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) 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 :: (~>) Nat ((~>) Nat Nat)+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) (x0123456789876543210 :: Nat) (a0123456789876543210 :: 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 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 ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (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-      suppressUnusedWarnings-        = snd ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) ())-    type family (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where-      (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210-    type family (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 (a :: Nat) (a :: Nat) :: Nat where+    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+      (<<<%%%%%%%%%%%%%%%%%%%%) 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 (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>-                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210-    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210-    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) 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 :: (~>) Nat ((~>) Nat Nat)+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) (x0123456789876543210 :: Nat) (a0123456789876543210 :: 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 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 ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (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-      suppressUnusedWarnings-        = snd ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) ())-    type family (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where-      (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210-    type family Let0123456789876543210Z x0123456789876543210 :: Nat where+    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 (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 (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+      (<<<%%%%%%%%%%%%%%%%%%%%) x ('Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) n) m)+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) (x0123456789876543210 :: Nat) :: (~>) Nat ((~>) Nat Nat)       where-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: SameKind (Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>-                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210-    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210-    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) 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 :: (~>) Nat ((~>) Nat Nat)+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) (x0123456789876543210 :: Nat) (a0123456789876543210 :: 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 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 ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (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-      suppressUnusedWarnings-        = snd ((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) ())-    type family (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where-      (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210-    type family (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 (a :: Nat) (a :: Nat) :: Nat where+    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_01234567898765432100123456789876543210 x0123456789876543210 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 x0123456789876543210 (a :: Nat) :: Nat where-      Let0123456789876543210Z x a_0123456789876543210 = Apply (Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) x) a_0123456789876543210-    type family Lambda_0123456789876543210 x0123456789876543210 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 x0123456789876543210 :: Nat where-      Let0123456789876543210Z x = Apply (Apply Lambda_0123456789876543210Sym0 x) ZeroSym0-    data Let0123456789876543210XSym0 x0123456789876543210+    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 x0123456789876543210 :: 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+    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-      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 x0123456789876543210 (a :: Nat) :: Nat where+    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 x0123456789876543210 :: 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 y0123456789876543210 x0123456789876543210 :: 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+    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-      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 x0123456789876543210 (a :: Nat) :: Nat where-      Let0123456789876543210F x y = Apply SuccSym0 (Let0123456789876543210ZSym2 y x)-    data Let0123456789876543210FSym0 x0123456789876543210+    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-        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-      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 x0123456789876543210 (a :: Nat) :: Nat where+    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 x0123456789876543210 :: 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@@ -556,24 +398,17 @@       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 x0123456789876543210 :: 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 ())     type Foo14Sym1 :: Nat -> (Nat, Nat)@@ -585,7 +420,7 @@       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 ())     type Foo13_Sym1 :: a -> a@@ -596,7 +431,7 @@       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 ())     type Foo13Sym1 :: forall a. a -> a@@ -607,7 +442,7 @@       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 ())     type Foo12Sym1 :: Nat -> Nat@@ -618,7 +453,7 @@       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 ())     type Foo11Sym1 :: Nat -> Nat@@ -629,7 +464,7 @@       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 ())     type Foo10Sym1 :: Nat -> Nat@@ -640,7 +475,7 @@       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 ())     type Foo9Sym1 :: Nat -> Nat@@ -651,7 +486,7 @@       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 ())     type Foo8Sym1 :: Nat -> Nat@@ -662,7 +497,7 @@       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 ())     type Foo7Sym1 :: Nat -> Nat@@ -673,7 +508,7 @@       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 ())     type Foo6Sym1 :: Nat -> Nat@@ -684,7 +519,7 @@       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 ())     type Foo5Sym1 :: Nat -> Nat@@ -695,7 +530,7 @@       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 ())     type Foo4Sym1 :: Nat -> Nat@@ -706,7 +541,7 @@       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 ())     type Foo3Sym1 :: Nat -> Nat@@ -720,7 +555,7 @@       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 ())     type Foo1Sym1 :: Nat -> Nat@@ -728,108 +563,99 @@       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) :: a where       Foo13_ y = y     type Foo13 :: forall a. a -> a     type family Foo13 @a (a :: a) :: a where-      Foo13 @a (x :: a) = Apply Foo13_Sym0 (Let0123456789876543210BarSym2 a x)+      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)) :: Type)+      (forall (t :: Nat). Sing t -> Sing (Foo14 t :: (Nat, Nat)) :: Type)     sFoo13_ ::-      (forall (t :: a). Sing t -> Sing (Apply Foo13_Sym0 t :: a) :: Type)-    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) :: Type)+      (forall (t :: Nat). Sing t -> Sing (Foo12 t :: Nat) :: Type)     sFoo11 ::-      (forall (t :: Nat).-       Sing t -> Sing (Apply Foo11Sym0 t :: Nat) :: Type)+      (forall (t :: Nat). Sing t -> Sing (Foo11 t :: Nat) :: Type)     sFoo10 ::-      (forall (t :: Nat).-       Sing t -> Sing (Apply Foo10Sym0 t :: Nat) :: Type)+      (forall (t :: Nat). Sing t -> Sing (Foo10 t :: Nat) :: Type)     sFoo9 ::-      (forall (t :: Nat).-       Sing t -> Sing (Apply Foo9Sym0 t :: Nat) :: Type)+      (forall (t :: Nat). Sing t -> Sing (Foo9 t :: Nat) :: Type)     sFoo8 ::-      (forall (t :: Nat).-       Sing t -> Sing (Apply Foo8Sym0 t :: Nat) :: Type)+      (forall (t :: Nat). Sing t -> Sing (Foo8 t :: Nat) :: Type)     sFoo7 ::-      (forall (t :: Nat).-       Sing t -> Sing (Apply Foo7Sym0 t :: Nat) :: Type)+      (forall (t :: Nat). Sing t -> Sing (Foo7 t :: Nat) :: Type)     sFoo6 ::-      (forall (t :: Nat).-       Sing t -> Sing (Apply Foo6Sym0 t :: Nat) :: Type)+      (forall (t :: Nat). Sing t -> Sing (Foo6 t :: Nat) :: Type)     sFoo5 ::-      (forall (t :: Nat).-       Sing t -> Sing (Apply Foo5Sym0 t :: Nat) :: Type)+      (forall (t :: Nat). Sing t -> Sing (Foo5 t :: Nat) :: Type)     sFoo4 ::-      (forall (t :: Nat).-       Sing t -> Sing (Apply Foo4Sym0 t :: Nat) :: Type)+      (forall (t :: Nat). Sing t -> Sing (Foo4 t :: Nat) :: Type)     sFoo3 ::-      (forall (t :: Nat).-       Sing t -> Sing (Apply Foo3Sym0 t :: Nat) :: Type)-    sFoo2 :: (Sing (Foo2Sym0 :: Nat) :: Type)+      (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) :: Type)+      (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@@ -840,7 +666,7 @@     sFoo13_ (sY :: Sing y) = sY     sFoo13 (sX :: Sing x)       = let-          sBar :: (Sing (Let0123456789876543210BarSym2 a x :: a) :: Type)+          sBar :: (Sing (Let0123456789876543210Bar a x :: a) :: Type)           sBar = sX         in applySing (singFun1 @Foo13_Sym0 sFoo13_) sBar     sFoo12 (sX :: Sing x)@@ -848,41 +674,39 @@           (%+) ::             (forall (t :: Nat) (t :: Nat).              Sing t-             -> Sing t-                -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat) :: Type)+             -> 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 (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (%+)) sN)                    sX)         in           applySing-            (applySing (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) (%+)) sX)+            (applySing (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (%+)) sX)             (applySing                (singFun1 @SuccSym0 SSucc)                (applySing (singFun1 @SuccSym0 SSucc) SZero))     sFoo11 (sX :: Sing x)       = let-          sZ :: (Sing (Let0123456789876543210ZSym1 x :: Nat) :: Type)+          sZ :: (Sing (Let0123456789876543210Z x :: Nat) :: Type)           (%+) ::             (forall (t :: Nat) (t :: Nat).              Sing t-             -> Sing t-                -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat) :: Type)+             -> 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 (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (%+)) sN)                    sM)         in           applySing             (applySing-               (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) (%+))+               (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (%+))                (applySing (singFun1 @SuccSym0 SSucc) SZero))             sZ     sFoo10 (sX :: Sing x)@@ -890,95 +714,90 @@           (%+) ::             (forall (t :: Nat) (t :: Nat).              Sing t-             -> Sing t-                -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat) :: Type)+             -> 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 (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$) x) (%+)) sN)                    sM)         in           applySing             (applySing-               (singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) (%+))+               (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) :: Type)+             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))+                   @(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) :: Type)+          sZ :: (Sing (Let0123456789876543210Z x :: Nat) :: Type)           sZ             = applySing                 (singFun1-                   @(Apply Lambda_0123456789876543210Sym0 x)-                   (\ sX -> case sX of (_ :: Sing x) -> sX))+                   @(LamCases_0123456789876543210Sym0 x)+                   (\cases (sX :: Sing x) -> sX))                 SZero         in sZ     sFoo7 (sX :: Sing x)       = let-          sX :: (Sing (Let0123456789876543210XSym1 x :: Nat) :: Type)+          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) :: Type)+             Sing t -> Sing (Let0123456789876543210F x t :: Nat) :: Type)           sF (sY :: Sing y) = applySing (singFun1 @SuccSym0 SSucc) sY in         let-          sZ :: (Sing (Let0123456789876543210ZSym1 x :: Nat) :: Type)-          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) :: Type)+             Sing t -> Sing (Let0123456789876543210F x t :: Nat) :: Type)           sF (sY :: Sing y)             = let-                sZ :: (Sing (Let0123456789876543210ZSym2 y x :: Nat) :: Type)+                sZ :: (Sing (Let0123456789876543210Z y x :: Nat) :: Type)                 sZ = applySing (singFun1 @SuccSym0 SSucc) sY               in applySing (singFun1 @SuccSym0 SSucc) sZ-        in applySing (singFun1 @(Let0123456789876543210FSym1 x) sF) sX+        in applySing (singFun1 @(Let0123456789876543210FSym0 x) sF) sX     sFoo4 (sX :: Sing x)       = let           sF ::             (forall (t :: Nat).-             Sing t-             -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat) :: Type)+             Sing t -> Sing (Let0123456789876543210F x t :: Nat) :: Type)           sF (sY :: Sing y) = applySing (singFun1 @SuccSym0 SSucc) sY-        in applySing (singFun1 @(Let0123456789876543210FSym1 x) sF) sX+        in applySing (singFun1 @(Let0123456789876543210FSym0 x) sF) sX     sFoo3 (sX :: Sing x)       = let-          sY :: (Sing (Let0123456789876543210YSym1 x :: Nat) :: Type)+          sY :: (Sing (Let0123456789876543210Y x :: Nat) :: Type)           sY = applySing (singFun1 @SuccSym0 SSucc) sX         in sY     sFoo2       = let-          sZ :: Sing @_ Let0123456789876543210ZSym0-          sY :: Sing @_ Let0123456789876543210YSym0+          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) :: Type)+          sY :: (Sing (Let0123456789876543210Y x :: Nat) :: Type)           sY = applySing (singFun1 @SuccSym0 SSucc) SZero         in sY     instance SingI (Foo14Sym0 :: (~>) Nat (Nat, Nat)) where
tests/compile-and-dump/Singletons/Maybe.golden view
@@ -15,82 +15,29 @@       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 ())     type JustSym1 :: forall a. a -> Maybe a     type family JustSym1 @a (a0123456789876543210 :: a) :: Maybe a where       JustSym1 a0123456789876543210 = Just a0123456789876543210-    type TFHelper_0123456789876543210 :: Maybe a -> Maybe a -> Bool+    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 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 @a (a0123456789876543210 :: Maybe a) (a0123456789876543210 :: Maybe a) :: Bool where-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+      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 (==) a a = TFHelper_0123456789876543210 a a+    type ShowsPrec_0123456789876543210 :: forall a. GHC.Num.Natural.Natural+                                                    -> Maybe a+                                                       -> GHC.Types.Symbol -> GHC.Types.Symbol     type family ShowsPrec_0123456789876543210 @a (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 @a (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+      ShowsPrec_0123456789876543210 @a (_ :: GHC.Num.Natural.Natural) (Nothing :: Maybe a) (a_0123456789876543210 :: GHC.Types.Symbol) = Apply (Apply ShowStringSym0 "Nothing") a_0123456789876543210+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Num.Natural.Natural) (Just arg_0123456789876543210 :: Maybe a) (a_0123456789876543210 :: GHC.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,13 +49,9 @@       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@@ -119,14 +62,6 @@             (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@@ -159,13 +94,13 @@             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 =>
tests/compile-and-dump/Singletons/Nat.golden view
@@ -32,7 +32,7 @@       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 ())     type SuccSym1 :: Nat -> Nat@@ -43,7 +43,7 @@       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 ())     type PredSym1 :: Nat -> Nat@@ -54,7 +54,7 @@       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 ())     type PlusSym1 :: Nat -> (~>) Nat Nat@@ -62,7 +62,7 @@       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 ())     type PlusSym2 :: Nat -> Nat -> Nat@@ -82,105 +82,28 @@       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 (==) a a = TFHelper_0123456789876543210 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       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 (<>@#@$)) 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) :: Type)+      (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) :: Type)+       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@@ -209,13 +132,9 @@       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@@ -226,14 +145,6 @@             (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@@ -265,11 +176,6 @@                      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@@ -294,13 +200,13 @@       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 =>
tests/compile-and-dump/Singletons/Natural.golden view
@@ -15,7 +15,7 @@       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 ())     type MkAgeSym1 :: Natural -> Age@@ -26,7 +26,7 @@       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 ())     type AddAgeSym1 :: Age -> (~>) Age Age@@ -34,7 +34,7 @@       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 ())     type AddAgeSym2 :: Age -> Age -> Age@@ -45,15 +45,15 @@       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) :: Type)+       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     instance SingI d =>@@ -70,8 +70,8 @@       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
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) :: Type)+    sF :: (Sing (F :: Natural) :: Type)     sF = sNegate (sFromInteger (sing :: Sing 1))- 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,7 +30,7 @@       where         (::+:@#@$###) :: SameKind (Apply (:+:@#@$) arg) ((:+:@#@$$) arg) =>                          (:+:@#@$) a0123456789876543210-    type instance Apply (:+:@#@$) a0123456789876543210 = (:+:@#@$$) a0123456789876543210+    type instance Apply @Foo @((~>) Foo Foo) (:+:@#@$) a0123456789876543210 = (:+:@#@$$) a0123456789876543210     instance SuppressUnusedWarnings (:+:@#@$) where       suppressUnusedWarnings = snd ((,) (::+:@#@$###) ())     type (:+:@#@$$) :: Foo -> (~>) Foo Foo@@ -38,7 +38,7 @@       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 ((,) (::+:@#@$$###) ())     type (:+:@#@$$$) :: Foo -> Foo -> Foo@@ -49,7 +49,7 @@       where         (:+@#@$###) :: SameKind (Apply (+@#@$) arg) ((+@#@$$) arg) =>                        (+@#@$) a0123456789876543210-    type instance Apply (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210+    type instance Apply @Nat @((~>) Nat Nat) (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210     instance SuppressUnusedWarnings (+@#@$) where       suppressUnusedWarnings = snd ((,) (:+@#@$###) ())     type (+@#@$$) :: Nat -> (~>) Nat Nat@@ -57,7 +57,7 @@       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 ((,) (:+@#@$$###) ())     type (+@#@$$$) :: Nat -> Nat -> Nat@@ -68,7 +68,7 @@       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 ())     type ChildSym1 :: Foo -> Foo@@ -84,11 +84,9 @@       Child ((:+:) a _) = a     (%+) ::       (forall (t :: Nat) (t :: Nat).-       Sing t-       -> Sing t -> Sing (Apply (Apply (+@#@$) t) t :: Nat) :: Type)+       Sing t -> Sing t -> Sing ((+) t t :: Nat) :: Type)     sChild ::-      (forall (t :: Foo).-       Sing t -> Sing (Apply ChildSym0 t :: Foo) :: Type)+      (forall (t :: Foo). Sing t -> Sing (Child t :: Foo) :: Type)     (%+) SZero (sM :: Sing m) = sM     (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)       = applySing@@ -118,8 +116,8 @@       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) =>
tests/compile-and-dump/Singletons/OrdDeriving.golden view
@@ -31,7 +31,7 @@       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 ())     type SuccSym1 :: Nat -> Nat@@ -45,7 +45,7 @@       where         ASym0KindInference :: SameKind (Apply ASym0 arg) (ASym1 arg) =>                               ASym0 a0123456789876543210-    type instance Apply ASym0 a0123456789876543210 = ASym1 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@@ -54,7 +54,7 @@       where         ASym1KindInference :: SameKind (Apply (ASym1 a0123456789876543210) arg) (ASym2 a0123456789876543210 arg) =>                               ASym1 a0123456789876543210 a0123456789876543210-    type instance Apply (ASym1 a0123456789876543210) a0123456789876543210 = ASym2 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@@ -63,7 +63,7 @@       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+    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)@@ -71,7 +71,7 @@       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+    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@@ -85,7 +85,7 @@       where         BSym0KindInference :: SameKind (Apply BSym0 arg) (BSym1 arg) =>                               BSym0 a0123456789876543210-    type instance Apply BSym0 a0123456789876543210 = BSym1 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@@ -94,7 +94,7 @@       where         BSym1KindInference :: SameKind (Apply (BSym1 a0123456789876543210) arg) (BSym2 a0123456789876543210 arg) =>                               BSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (BSym1 a0123456789876543210) a0123456789876543210 = BSym2 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@@ -103,7 +103,7 @@       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+    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)@@ -111,7 +111,7 @@       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+    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@@ -125,7 +125,7 @@       where         CSym0KindInference :: SameKind (Apply CSym0 arg) (CSym1 arg) =>                               CSym0 a0123456789876543210-    type instance Apply CSym0 a0123456789876543210 = CSym1 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@@ -134,7 +134,7 @@       where         CSym1KindInference :: SameKind (Apply (CSym1 a0123456789876543210) arg) (CSym2 a0123456789876543210 arg) =>                               CSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (CSym1 a0123456789876543210) a0123456789876543210 = CSym2 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@@ -143,7 +143,7 @@       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+    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)@@ -151,7 +151,7 @@       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+    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@@ -165,7 +165,7 @@       where         DSym0KindInference :: SameKind (Apply DSym0 arg) (DSym1 arg) =>                               DSym0 a0123456789876543210-    type instance Apply DSym0 a0123456789876543210 = DSym1 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@@ -174,7 +174,7 @@       where         DSym1KindInference :: SameKind (Apply (DSym1 a0123456789876543210) arg) (DSym2 a0123456789876543210 arg) =>                               DSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (DSym1 a0123456789876543210) a0123456789876543210 = DSym2 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@@ -183,7 +183,7 @@       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+    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)@@ -191,7 +191,7 @@       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+    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@@ -205,7 +205,7 @@       where         ESym0KindInference :: SameKind (Apply ESym0 arg) (ESym1 arg) =>                               ESym0 a0123456789876543210-    type instance Apply ESym0 a0123456789876543210 = ESym1 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@@ -214,7 +214,7 @@       where         ESym1KindInference :: SameKind (Apply (ESym1 a0123456789876543210) arg) (ESym2 a0123456789876543210 arg) =>                               ESym1 a0123456789876543210 a0123456789876543210-    type instance Apply (ESym1 a0123456789876543210) a0123456789876543210 = ESym2 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@@ -223,7 +223,7 @@       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+    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)@@ -231,7 +231,7 @@       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+    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@@ -245,7 +245,7 @@       where         FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>                               FSym0 a0123456789876543210-    type instance Apply FSym0 a0123456789876543210 = FSym1 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@@ -254,7 +254,7 @@       where         FSym1KindInference :: SameKind (Apply (FSym1 a0123456789876543210) arg) (FSym2 a0123456789876543210 arg) =>                               FSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (FSym1 a0123456789876543210) a0123456789876543210 = FSym2 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@@ -263,7 +263,7 @@       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+    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)@@ -271,7 +271,7 @@       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+    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@@ -283,186 +283,98 @@       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 (==) 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-    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 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 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 @a @b @c @d (a0123456789876543210 :: Foo a b c d) (a0123456789876543210 :: Foo a b c d) :: Bool where-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+      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 = Apply (Apply TFHelper_0123456789876543210Sym0 a) a-    type Compare_0123456789876543210 :: Foo a b c d-                                        -> Foo a b c d -> Ordering+      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 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (A b_0123456789876543210 b_0123456789876543210 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)) (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 (<>@#@$)) 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 (<>@#@$)) 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 (<>@#@$)) 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 (<>@#@$)) 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 (<>@#@$)) 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 @a @b @c @d (a0123456789876543210 :: Foo a b c d) (a0123456789876543210 :: Foo a b c d) :: Ordering where-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+      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 = Apply (Apply Compare_0123456789876543210Sym0 a) a+      type Compare a a = Compare_0123456789876543210 a a     data SNat :: Nat -> Type       where         SZero :: SNat (Zero :: Nat)@@ -474,7 +386,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)     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).@@ -531,64 +444,47 @@         = 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)+        = (\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))-        = 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)+        = (\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))-        = 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)+        = (\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))-        = 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)+        = (\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))-        = 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)+        = (\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))-        = 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)+        = (\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-      (%==) ::-        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@@ -599,11 +495,6 @@             (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@@ -627,11 +518,6 @@       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)@@ -844,11 +730,6 @@                      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)@@ -1109,13 +990,13 @@       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 {})+      (%~) 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 =>@@ -1131,107 +1012,89 @@     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 {})+        = (\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)-        = 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 {})+        = (\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)-        = 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 {})+        = (\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)-        = 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 {})+        = (\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)-        = 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 {})+        = (\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)-        = 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)+        = (\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) =>
tests/compile-and-dump/Singletons/OverloadedStrings.golden view
@@ -17,7 +17,7 @@       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 ())     type SymIdSym1 :: Symbol -> Symbol@@ -29,10 +29,9 @@     type SymId :: Symbol -> Symbol     type family SymId (a :: Symbol) :: Symbol where       SymId x = x-    sFoo :: (Sing (FooSym0 :: Symbol) :: Type)+    sFoo :: (Sing (Foo :: Symbol) :: Type)     sSymId ::-      (forall (t :: Symbol).-       Sing t -> Sing (Apply SymIdSym0 t :: Symbol) :: Type)+      (forall (t :: Symbol). Sing t -> Sing (SymId t :: Symbol) :: Type)     sFoo       = applySing           (singFun1 @SymIdSym0 sSymId) (sFromString (sing :: Sing "foo"))
tests/compile-and-dump/Singletons/PatternMatching.golden view
@@ -21,7 +21,7 @@       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 ())     type PairSym1 :: forall a b. a -> (~>) b (Pair a b)@@ -29,7 +29,7 @@       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 ())     type PairSym2 :: forall a b. a -> b -> Pair a b@@ -51,49 +51,17 @@       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 ShowsPrec_0123456789876543210 :: forall a+                                                 b. GHC.Num.Natural.Natural+                                                    -> Pair a b -> Symbol -> Symbol     type family ShowsPrec_0123456789876543210 @a @b (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 @a @b (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Pair a b) (a0123456789876543210 :: Symbol) :: Symbol where-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+      ShowsPrec_0123456789876543210 @a @b (p_0123456789876543210 :: GHC.Num.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)@@ -139,17 +107,9 @@       type Demote (Pair a b) = Pair (Demote a) (Demote 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)@@ -228,143 +188,195 @@     foo2 t@(# x, y #) = case t of (# a, b #) -> (\ _ -> a) b     silly :: a -> ()     silly x = case x of _ -> ()-    type family Case_0123456789876543210 x0123456789876543210 t where-      Case_0123456789876543210 x _ = Tuple0Sym0-    data Let0123456789876543210TSym0 x0123456789876543210-      where-        Let0123456789876543210TSym0KindInference :: SameKind (Apply Let0123456789876543210TSym0 arg) (Let0123456789876543210TSym1 arg) =>-                                                    Let0123456789876543210TSym0 x0123456789876543210-    type instance Apply Let0123456789876543210TSym0 x0123456789876543210 = Let0123456789876543210TSym1 x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210TSym0 where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210TSym0KindInference ())-    data Let0123456789876543210TSym1 x0123456789876543210 y0123456789876543210+    type family LamCases_0123456789876543210 (x0123456789876543210 :: a0123456789876543210) a_0123456789876543210 where+      LamCases_0123456789876543210 x _ = Tuple0Sym0+    data LamCases_0123456789876543210Sym0 (x0123456789876543210 :: a0123456789876543210) 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 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 ((,) Let0123456789876543210TSym1KindInference ())-    type family Let0123456789876543210TSym2 x0123456789876543210 y0123456789876543210 where-      Let0123456789876543210TSym2 x0123456789876543210 y0123456789876543210 = Let0123456789876543210T 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 Case_0123456789876543210 arg_01234567898765432100123456789876543210 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 a b x y _ = a-    type family Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 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+    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-        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 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 ((,) Lambda_0123456789876543210Sym0KindInference ())-    data Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210+        = 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_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 x0123456789876543210 y0123456789876543210 a_0123456789876543210 where+      LamCases_0123456789876543210 x y _ = x+    data LamCases_0123456789876543210Sym0 x0123456789876543210 y0123456789876543210 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 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 ())-    data Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210+        = 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_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,+                                     'Succ _] = 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 x0123456789876543210 y0123456789876543210 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_01234567898765432100123456789876543210 x0123456789876543210 y0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 x y _ = x-    type family Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 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 '(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 ('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 ())     type SillySym1 :: a -> ()@@ -375,7 +387,8 @@       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 ())     type Foo2Sym1 :: (a, b) -> a@@ -387,7 +400,8 @@       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 ())     type Foo1Sym1 :: (a, b) -> a@@ -426,173 +440,183 @@       X_0123456789876543210Sym0 = X_0123456789876543210     type Silly :: a -> ()     type family Silly @a (a :: a) :: () where-      Silly x = Case_0123456789876543210 x x+      Silly x = Apply (LamCases_0123456789876543210Sym0 x) x     type Foo2 :: (a, b) -> a     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 @b (a :: (a, b)) :: a where-      Foo1 '(x,-             y) = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y+      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 (t :: a). Sing t -> Sing (Apply SillySym0 t :: ()) :: Type)+    sSilly :: (forall (t :: a). Sing t -> Sing (Silly t :: ()) :: Type)     sFoo2 ::-      (forall (t :: (a, b)).-       Sing t -> Sing (Apply Foo2Sym0 t :: a) :: Type)+      (forall (t :: (a, b)). Sing t -> Sing (Foo2 t :: a) :: Type)     sFoo1 ::-      (forall (t :: (a, b)).-       Sing t -> Sing (Apply Foo1Sym0 t :: a) :: Type)-    sBlimy :: Sing @_ BlimySym0-    sLsz :: (Sing (LszSym0 :: Nat) :: Type)-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0-    sTt :: Sing @_ TtSym0-    sTjz :: Sing @_ TjzSym0-    sTf :: Sing @_ TfSym0-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0-    sFls :: (Sing (FlsSym0 :: Bool) :: Type)-    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 :: Sing @_ (Let0123456789876543210T x y)           sT = applySing (applySing (singFun2 @Tuple2Sym0 STuple2) sX) sY         in-          id-            @(Sing (Case_0123456789876543210 x y (Let0123456789876543210TSym2 x y)))-            (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)))+          (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))-          (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))-          (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
tests/compile-and-dump/Singletons/PolyKinds.golden view
@@ -10,7 +10,7 @@       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 ())     type FffSym1 :: forall k (a :: k). Proxy (a :: k) -> ()@@ -21,7 +21,7 @@     class SCls (a :: k) where       sFff ::         (forall (t :: Proxy (a :: k)).-         Sing t -> Sing (Apply FffSym0 t :: ()) :: Type)+         Sing t -> Sing (Fff t :: ()) :: Type)     instance SCls a =>              SingI (FffSym0 :: (~>) (Proxy (a :: k)) ()) where       sing = singFun1 @FffSym0 sFff
tests/compile-and-dump/Singletons/PolyKindsApp.golden view
@@ -13,4 +13,4 @@     class PCls (a :: k -> Type) where       type family Fff :: (a :: k -> Type) (b :: k)     class SCls (a :: k -> Type) where-      sFff :: (Sing (FffSym0 :: (a :: k -> Type) (b :: k)) :: Type)+      sFff :: (Sing (Fff :: (a :: k -> Type) (b :: k)) :: Type)
tests/compile-and-dump/Singletons/Records.golden view
@@ -8,7 +8,7 @@       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 ())     type MkRecordSym1 :: forall a. a -> (~>) Bool (Record a)@@ -16,7 +16,7 @@       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 ())     type MkRecordSym2 :: forall a. a -> Bool -> Record a@@ -27,7 +27,7 @@       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 ())     type Field2Sym1 :: forall a. Record a -> Bool@@ -38,7 +38,7 @@       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 ())     type Field1Sym1 :: forall a. Record a -> a@@ -51,10 +51,8 @@     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@@ -70,8 +68,8 @@       type Demote (Record a) = Record (Demote a)       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
tests/compile-and-dump/Singletons/ReturnFunc.golden view
@@ -18,7 +18,7 @@       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 ())     type IdFooSym1 :: c -> (~>) a a@@ -26,7 +26,7 @@       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 ())     type IdFooSym2 :: c -> a -> a@@ -37,7 +37,7 @@       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 ())     type IdSym1 :: a -> a@@ -48,7 +48,7 @@       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 ())     type ReturnFuncSym1 :: Nat -> (~>) Nat Nat@@ -56,7 +56,7 @@       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 ())     type ReturnFuncSym2 :: Nat -> Nat -> Nat@@ -73,15 +73,11 @@       ReturnFunc _ a_0123456789876543210 = Apply SuccSym0 a_0123456789876543210     sIdFoo ::       (forall (t :: c) (t :: a).-       Sing t-       -> Sing t -> Sing (Apply (Apply IdFooSym0 t) t :: a) :: Type)-    sId ::-      (forall (t :: a). Sing t -> Sing (Apply IdSym0 t :: a) :: Type)+       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) :: Type)+       Sing t -> Sing t -> Sing (ReturnFunc t t :: Nat) :: Type)     sIdFoo _ (sA_0123456789876543210 :: Sing a_0123456789876543210)       = applySing (singFun1 @IdSym0 sId) sA_0123456789876543210     sId (sX :: Sing x) = sX
tests/compile-and-dump/Singletons/Sections.golden view
@@ -19,18 +19,18 @@     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+    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,7 +45,7 @@       where         (:+@#@$###) :: SameKind (Apply (+@#@$) arg) ((+@#@$$) arg) =>                        (+@#@$) a0123456789876543210-    type instance Apply (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210+    type instance Apply @Nat @((~>) Nat Nat) (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210     instance SuppressUnusedWarnings (+@#@$) where       suppressUnusedWarnings = snd ((,) (:+@#@$###) ())     type (+@#@$$) :: Nat -> (~>) Nat Nat@@ -53,7 +53,7 @@       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 ((,) (:+@#@$$###) ())     type (+@#@$$$) :: Nat -> Nat -> Nat@@ -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,13 +72,12 @@     type family (+) (a :: Nat) (a :: Nat) :: Nat where       (+) 'Zero m = m       (+) ('Succ n) m = Apply SuccSym0 (Apply (Apply (+@#@$) n) m)-    sFoo3 :: (Sing (Foo3Sym0 :: [Nat]) :: Type)-    sFoo2 :: (Sing (Foo2Sym0 :: [Nat]) :: Type)-    sFoo1 :: (Sing (Foo1Sym0 :: [Nat]) :: Type)+    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) :: Type)+       Sing t -> Sing t -> Sing ((+) t t :: Nat) :: Type)     sFoo3       = applySing           (applySing@@ -105,13 +104,12 @@           (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))))+                @LamCases_0123456789876543210Sym0+                (\cases+                   (sLhs_0123456789876543210 :: Sing lhs_0123456789876543210)+                     -> applySing+                          (applySing (singFun2 @(+@#@$) (%+)) sLhs_0123456789876543210)+                          (applySing (singFun1 @SuccSym0 SSucc) SZero))))           (applySing              (applySing (singFun2 @(:@#@$) SCons) SZero)              (applySing
tests/compile-and-dump/Singletons/ShowDeriving.golden view
@@ -32,7 +32,7 @@       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 ())     type MkFoo2aSym1 :: forall a. a -> (~>) a (Foo2 a)@@ -40,7 +40,7 @@       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 ())     type MkFoo2aSym2 :: forall a. a -> a -> Foo2 a@@ -51,73 +51,73 @@       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`+    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`+    infixl 5 type `MkFoo2bSym1`     type MkFoo2bSym2 :: forall a. a -> a -> Foo2 a     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 :*:@#@$+    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 :*:@#@$$+    infixl 5 type :*:@#@$$     type (:*:@#@$$$) :: forall a. a -> a -> Foo2 a     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 :&:@#@$+    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 :&:@#@$$+    infixl 5 type :&:@#@$$     type (:&:@#@$$$) :: forall a. a -> a -> Foo2 a     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 ())     type MkFoo3Sym1 :: Bool -> (~>) Bool Foo3@@ -125,7 +125,7 @@       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 ())     type MkFoo3Sym2 :: Bool -> Bool -> Foo3@@ -136,7 +136,7 @@       where         (:***@#@$###) :: SameKind (Apply (***@#@$) arg) ((***@#@$$) arg) =>                          (***@#@$) a0123456789876543210-    type instance Apply (***@#@$) a0123456789876543210 = (***) a0123456789876543210+    type instance Apply @Foo3 @Bool (***@#@$) a0123456789876543210 = (***) a0123456789876543210     instance SuppressUnusedWarnings (***@#@$) where       suppressUnusedWarnings = snd ((,) (:***@#@$###) ())     type (***@#@$$) :: Foo3 -> Bool@@ -147,7 +147,7 @@       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 ())     type GetFoo3aSym1 :: Foo3 -> Bool@@ -163,131 +163,30 @@                                           -> Foo1 -> Symbol -> Symbol     type family ShowsPrec_0123456789876543210 (a :: GHC.Num.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 ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a+    type ShowsPrec_0123456789876543210 :: forall a. GHC.Num.Natural.Natural+                                                    -> Foo2 a -> Symbol -> Symbol     type family ShowsPrec_0123456789876543210 @a (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 @a (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo2 a) (a0123456789876543210 :: Symbol) :: Symbol where-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Num.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.Num.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.Num.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.Num.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 a a a = ShowsPrec_0123456789876543210 a a a     type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural                                           -> Foo3 -> Symbol -> Symbol     type family ShowsPrec_0123456789876543210 (a :: GHC.Num.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) :: Type)+      (forall (t :: Foo3). Sing t -> Sing ((***) t :: Bool) :: Type)     sGetFoo3a ::-      (forall (t :: Foo3).-       Sing t -> Sing (Apply GetFoo3aSym0 t :: Bool) :: Type)+      (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@@ -318,17 +217,17 @@       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).@@ -338,19 +237,9 @@       type Demote Foo3 = Foo3       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@@ -360,14 +249,6 @@                (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)@@ -500,14 +381,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)
tests/compile-and-dump/Singletons/StandaloneDeriving.golden view
@@ -30,278 +30,116 @@       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 :*:@#@$+    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 :*:@#@$$+    infixl 6 type :*:@#@$$     type (:*:@#@$$$) :: forall a b. a -> b -> T a b     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 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_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 @a (a0123456789876543210 :: T a ()) (a0123456789876543210 :: T a ()) :: Bool where-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+      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 (==) 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_0123456789876543210 a_0123456789876543210) ((:*:) 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))-    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 @a (a0123456789876543210 :: T a ()) (a0123456789876543210 :: T a ()) :: Ordering where-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+      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 Compare a a = Compare_0123456789876543210 a a+    type ShowsPrec_0123456789876543210 :: forall a. GHC.Num.Natural.Natural+                                                    -> T a () -> Symbol -> Symbol     type family ShowsPrec_0123456789876543210 @a (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 @a (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: T a ()) (a0123456789876543210 :: Symbol) :: Symbol where-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Num.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 (<>@#@$)) 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 Compare a a = Compare_0123456789876543210 a a     type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural                                           -> S -> Symbol -> Symbol     type family ShowsPrec_0123456789876543210 (a :: GHC.Num.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 n0123456789876543210 t where-      Case_0123456789876543210 n 'True = S2Sym0-      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"-    type family Case_0123456789876543210 n0123456789876543210 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.Num.Natural.Natural) a_0123456789876543210 where+      LamCases_0123456789876543210 n 'True = S2Sym0+      LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Num.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+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Num.Natural.Natural) a_01234567898765432100123456789876543210 where+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Num.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.Num.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.Num.Natural.Natural) a_01234567898765432100123456789876543210 where+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210+    type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> S+    type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: S where+      ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0))     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-      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 :: S-                                             -> GHC.Num.Natural.Natural-    type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: S) :: GHC.Num.Natural.Natural where-      FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210     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).@@ -311,8 +149,8 @@       type Demote (T a b) = T (Demote a) (Demote 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,11 +163,6 @@       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))@@ -345,11 +178,6 @@                (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))@@ -373,14 +201,6 @@                         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)@@ -413,21 +233,11 @@                         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@@ -443,14 +253,6 @@       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@@ -468,48 +270,40 @@                (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 =>@@ -524,8 +318,8 @@         = 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 Eq (SS (z :: S)) where       (==) _ _ = True
tests/compile-and-dump/Singletons/Star.golden view
@@ -23,7 +23,7 @@       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 ())     type MaybeSym1 :: Type -> Type@@ -34,7 +34,7 @@       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 ())     type VecSym1 :: Type -> (~>) Nat Type@@ -42,7 +42,7 @@       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 ())     type VecSym2 :: Type -> Nat -> Type@@ -75,29 +75,8 @@       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 (<>@#@$)) EQSym0) NilSym0@@ -125,29 +104,8 @@       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 Compare a a = Compare_0123456789876543210 a a     type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural                                           -> Type -> Symbol -> Symbol     type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Type) (a :: Symbol) :: Symbol where@@ -156,41 +114,8 @@       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)@@ -211,49 +136,46 @@       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) =>@@ -265,11 +187,6 @@                                                                    -> 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@@ -314,11 +231,6 @@                (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@@ -394,14 +306,6 @@       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
tests/compile-and-dump/Singletons/T124.golden view
@@ -12,7 +12,7 @@       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 ())     type FooSym1 :: Bool -> ()@@ -22,9 +22,7 @@     type family Foo (a :: Bool) :: () where       Foo 'True = Tuple0Sym0       Foo 'False = Tuple0Sym0-    sFoo ::-      (forall (t :: Bool).-       Sing t -> Sing (Apply FooSym0 t :: ()) :: Type)+    sFoo :: (forall (t :: Bool). Sing t -> Sing (Foo t :: ()) :: Type)     sFoo STrue = STuple0     sFoo SFalse = STuple0     instance SingI (FooSym0 :: (~>) Bool ()) where@@ -32,6 +30,7 @@ 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,99 +34,65 @@       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.Num.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.Num.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 i0123456789876543210 arg_01234567898765432100123456789876543210 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 i0123456789876543210 arg_01234567898765432100123456789876543210 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_01234567898765432100123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 i = Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (<@#@$) i) (FromInteger 0))+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())+    type family LamCases_0123456789876543210Sym1 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Num.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.Num.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.Num.Natural.Natural) a_01234567898765432100123456789876543210+      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 ((,) LamCases_0123456789876543210Sym0KindInference ())+    type family LamCases_0123456789876543210Sym1 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Num.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.Num.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.Num.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.Num.Natural.Natural) a_01234567898765432100123456789876543210 where+      LamCases_0123456789876543210Sym1 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210     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]-      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-      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+      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       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       sSucc (SCons SFalse (sAs :: Sing as))@@ -135,7 +101,8 @@         = applySing             (applySing (singFun2 @(:@#@$) SCons) SFalse)             (applySing (singFun1 @SuccSym0 sSucc) sAs)-      sPred SNil = sError (sing :: Sing "pred 0")+      sPred SNil+        = applySing (singFun1 @ErrorSym0 sError) (sing :: Sing "pred 0")       sPred (SCons SFalse (sAs :: Sing as))         = applySing             (applySing (singFun2 @(:@#@$) SCons) STrue)@@ -143,33 +110,37 @@       sPred (SCons STrue (sAs :: Sing as))         = 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
tests/compile-and-dump/Singletons/T136b.golden view
@@ -10,7 +10,7 @@       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 ())     type MethSym1 :: forall a. a -> a@@ -19,8 +19,7 @@     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) :: Type)+      sMeth :: (forall (t :: a). Sing t -> Sing (Meth t :: a) :: Type)     instance SC a => SingI (MethSym0 :: (~>) a a) where       sing = singFun1 @MethSym0 sMeth Singletons/T136b.hs:(0,0)-(0,0): Splicing declarations@@ -33,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
tests/compile-and-dump/Singletons/T145.golden view
@@ -10,7 +10,7 @@       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 ())     type ColSym1 :: forall f a. f a -> (~>) a Bool@@ -18,7 +18,7 @@       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 ())     type ColSym2 :: forall f a. f a -> a -> Bool@@ -29,8 +29,7 @@     class SColumn (f :: Type -> Type) where       sCol ::         (forall (t :: f a) (t :: a).-         Sing t-         -> Sing t -> Sing (Apply (Apply ColSym0 t) t :: Bool) :: Type)+         Sing t -> Sing t -> Sing (Col t t :: Bool) :: Type)     instance SColumn f =>              SingI (ColSym0 :: (~>) (f a) ((~>) a Bool)) where       sing = singFun2 @ColSym0 sCol
tests/compile-and-dump/Singletons/T150.golden view
@@ -78,7 +78,7 @@       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 ())     type FSSym1 :: Fin n -> Fin ('Succ n)@@ -98,7 +98,7 @@       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 ())     type VConsSym1 :: a -> (~>) (Vec n a) (Vec ('Succ n) a)@@ -106,7 +106,7 @@       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 ())     type VConsSym2 :: a -> Vec n a -> Vec ('Succ n) a@@ -123,7 +123,7 @@       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 ())     type HConsSym1 :: x -> (~>) (HList xs) (HList ('(:) x xs))@@ -131,7 +131,7 @@       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 ())     type HConsSym2 :: x -> HList xs -> HList ('(:) x xs)@@ -142,19 +142,29 @@       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 ())     type ObjSym1 :: a -> Obj     type family ObjSym1 @a (a0123456789876543210 :: a) :: Obj where       ObjSym1 a0123456789876543210 = Obj a0123456789876543210-    type family Case_0123456789876543210 n0123456789876543210 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 ())     type TransitivitySym1 :: Equal a b -> (~>) (Equal b c) (Equal a c)@@ -162,7 +172,7 @@       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 ())     type TransitivitySym2 :: Equal a b -> Equal b c -> Equal a c@@ -173,7 +183,7 @@       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 ())     type SymmetrySym1 :: Equal a b -> Equal b a@@ -184,7 +194,7 @@       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 ())     type MapVecSym1 :: (~>) a b -> (~>) (Vec n a) (Vec n b)@@ -192,7 +202,7 @@       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 ())     type MapVecSym2 :: (~>) a b -> Vec n a -> Vec n b@@ -203,7 +213,7 @@       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 ((,) (:!@#@$###) ())     type (!@#@$$) :: Vec n a -> (~>) (Fin n) a@@ -211,7 +221,7 @@       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 ((,) (:!@#@$$###) ())     type (!@#@$$$) :: Vec n a -> Fin n -> a@@ -222,7 +232,7 @@       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 ())     type TailVecSym1 :: Vec ('Succ n) a -> Vec n a@@ -233,7 +243,7 @@       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 ())     type HeadVecSym1 :: Vec ('Succ n) a -> a@@ -253,7 +263,7 @@     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 @n @a (a :: Vec ('Succ n) a) :: Vec n a where       TailVec (VCons _ xs) = xs@@ -262,26 +272,22 @@       HeadVec (VCons x _) = x     sTransitivity ::       (forall (t :: Equal a b) (t :: Equal b c).-       Sing t-       -> Sing t-          -> Sing (Apply (Apply TransitivitySym0 t) t :: Equal a c) :: Type)+       Sing t -> Sing t -> Sing (Transitivity t t :: Equal a c) :: Type)     sSymmetry ::       (forall (t :: Equal a b).-       Sing t -> Sing (Apply SymmetrySym0 t :: Equal b a) :: Type)+       Sing t -> Sing (Symmetry t :: Equal b a) :: Type)     sMapVec ::       (forall (t :: (~>) a b) (t :: Vec n a).-       Sing t-       -> Sing t-          -> Sing (Apply (Apply MapVecSym0 t) t :: Vec n b) :: Type)+       Sing t -> Sing t -> Sing (MapVec t t :: Vec n b) :: Type)     (%!) ::       (forall (t :: Vec n a) (t :: Fin n).-       Sing t -> Sing t -> Sing (Apply (Apply (!@#@$) t) t :: a) :: Type)+       Sing t -> Sing t -> Sing ((!) t t :: a) :: Type)     sTailVec ::       (forall (t :: Vec ('Succ n) a).-       Sing t -> Sing (Apply TailVecSym0 t :: Vec n a) :: Type)+       Sing t -> Sing (TailVec t :: Vec n a) :: Type)     sHeadVec ::       (forall (t :: Vec ('Succ n) a).-       Sing t -> Sing (Apply HeadVecSym0 t :: a) :: Type)+       Sing t -> Sing (HeadVec t :: a) :: Type)     sTransitivity SReflexive SReflexive = SReflexive     sSymmetry SReflexive = SReflexive     sMapVec _ SVNil = SVNil@@ -293,7 +299,8 @@     (%!) (SVCons _ (sXs :: Sing xs)) (SFS (sN :: Sing n))       = applySing (applySing (singFun2 @(!@#@$) (%!)) sXs) sN     (%!) SVNil (sN :: Sing n)-      = id @(Sing (Case_0123456789876543210 n n)) (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
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`+    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`+    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 :&&@#@$+    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 :&&@#@$$+    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@@ -118,13 +118,13 @@       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) =>@@ -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`+    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`+    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 :||@#@$+    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 :||@#@$$+    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)@@ -230,11 +230,11 @@       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
tests/compile-and-dump/Singletons/T160.golden view
@@ -5,30 +5,25 @@   ======>     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 x0123456789876543210 where-      Let0123456789876543210Scrutinee_0123456789876543210 x = Apply (Apply (==@#@$) x) (FromInteger 0)-    type family Case_0123456789876543210 x0123456789876543210 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 ())     type FooSym1 :: a -> a@@ -36,28 +31,24 @@       FooSym1 a0123456789876543210 = Foo a0123456789876543210     type Foo :: a -> a     type family Foo @a (a :: a) :: a where-      Foo x = Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)+      Foo x = Apply (LamCases_0123456789876543210Sym0 x) (Apply (Apply (==@#@$) x) (FromInteger 0))     sFoo ::       (forall (t :: a).-       (SNum a, SEq a) => Sing t -> Sing (Apply FooSym0 t :: a) :: Type)+       (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)))-            (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: [GHC-64725]
tests/compile-and-dump/Singletons/T163.golden view
@@ -7,7 +7,7 @@       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 ())     type LSym1 :: forall a b. a -> (+) a b@@ -18,7 +18,7 @@       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 ())     type RSym1 :: forall a b. b -> (+) a b@@ -34,9 +34,9 @@       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
tests/compile-and-dump/Singletons/T166.golden view
@@ -10,7 +10,7 @@       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 ())     type FoosPrecSym1 :: forall a. Natural@@ -19,7 +19,7 @@       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 ())     type FoosPrecSym2 :: forall a. Natural -> a -> (~>) [Bool] [Bool]@@ -27,7 +27,7 @@       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 ())     type FoosPrecSym3 :: forall a. Natural -> a -> [Bool] -> [Bool]@@ -38,78 +38,52 @@       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 ())     type FooSym1 :: forall a. a -> [Bool]     type family FooSym1 @a (a0123456789876543210 :: a) :: [Bool] where       FooSym1 a0123456789876543210 = Foo a0123456789876543210-    type family Lambda_0123456789876543210 x0123456789876543210 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+    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-        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+        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_0123456789876543210Sym1KindInference ())-    type family Lambda_0123456789876543210Sym2 x0123456789876543210 s0123456789876543210 where-      Lambda_0123456789876543210Sym2 x0123456789876543210 s0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 s0123456789876543210-    type Foo_0123456789876543210 :: a -> [Bool]+        = 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 x = Apply Lambda_0123456789876543210Sym0 x-    type Foo_0123456789876543210Sym0 :: (~>) a [Bool]-    data Foo_0123456789876543210Sym0 :: (~>) a [Bool]-      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-      suppressUnusedWarnings-        = snd ((,) Foo_0123456789876543210Sym0KindInference ())-    type Foo_0123456789876543210Sym1 :: a -> [Bool]-    type family Foo_0123456789876543210Sym1 @a (a0123456789876543210 :: a) :: [Bool] where-      Foo_0123456789876543210Sym1 a0123456789876543210 = Foo_0123456789876543210 a0123456789876543210+      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]) :: Type)-      sFoo ::-        (forall (t :: a).-         Sing t -> Sing (Apply FooSym0 t :: [Bool]) :: Type)+         -> 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]) :: Type)+                 ((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)+            @(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@@ -141,12 +115,12 @@     instance SFoo a => SingI (FooSym0 :: (~>) a [Bool]) where       sing = singFun1 @FooSym0 sFoo Singletons/T166.hs:0:0: error: [GHC-83865]-    • Expecting one more argument to ‘Apply Lambda_0123456789876543210Sym0 x’+    • 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,7 +13,7 @@       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 ())     type FoosPrecSym1 :: forall a. Natural@@ -22,7 +22,7 @@       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 ())     type FoosPrecSym2 :: forall a. Natural -> a -> (~>) [Bool] [Bool]@@ -30,7 +30,7 @@       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 ())     type FoosPrecSym3 :: forall a. Natural -> a -> [Bool] -> [Bool]@@ -41,7 +41,7 @@       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 ())     type FooListSym1 :: forall a. a -> (~>) [Bool] [Bool]@@ -49,109 +49,44 @@       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 ())     type FooListSym2 :: forall a. a -> [Bool] -> [Bool]     type family FooListSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where       FooListSym2 a0123456789876543210 a0123456789876543210 = FooList a0123456789876543210 a0123456789876543210-    type FooList_0123456789876543210 :: a -> [Bool] -> [Bool]+    type FooList_0123456789876543210 :: forall a. a -> [Bool] -> [Bool]     type family FooList_0123456789876543210 @a (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 @a (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where-      FooList_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = FooList_0123456789876543210 a0123456789876543210 a0123456789876543210+      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 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_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 @a (a0123456789876543210 :: Natural) (a0123456789876543210 :: [a]) (a0123456789876543210 :: [Bool]) :: [Bool] where-      FoosPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = FoosPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+      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]) :: Type)+         -> 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]) :: Type)+         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]) :: Type)+                 ((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]) :: Type)       sFoosPrec         _         (sA_0123456789876543210 :: Sing a_0123456789876543210)
tests/compile-and-dump/Singletons/T172.golden view
@@ -8,7 +8,7 @@       where         (:$>@#@$###) :: SameKind (Apply ($>@#@$) arg) (($>@#@$$) arg) =>                         ($>@#@$) a0123456789876543210-    type instance Apply ($>@#@$) a0123456789876543210 = ($>@#@$$) a0123456789876543210+    type instance Apply @Natural @((~>) Natural Natural) ($>@#@$) a0123456789876543210 = ($>@#@$$) a0123456789876543210     instance SuppressUnusedWarnings ($>@#@$) where       suppressUnusedWarnings = snd ((,) (:$>@#@$###) ())     type ($>@#@$$) :: Natural -> (~>) Natural Natural@@ -16,7 +16,7 @@       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 ((,) (:$>@#@$$###) ())     type ($>@#@$$$) :: Natural -> Natural -> Natural@@ -27,8 +27,7 @@       ($>) 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) :: Type)+       Sing t -> Sing t -> Sing (($>) t t :: Natural) :: Type)     (%$>)       (sA_0123456789876543210 :: Sing a_0123456789876543210)       (sA_0123456789876543210 :: Sing a_0123456789876543210)
tests/compile-and-dump/Singletons/T175.golden view
@@ -32,24 +32,21 @@     type Quux1Sym0 :: forall a. a     type family Quux1Sym0 @a :: a where       Quux1Sym0 = Quux1-    type Quux1_0123456789876543210 :: a+    type Quux1_0123456789876543210 :: forall a. a     type family Quux1_0123456789876543210 @a :: a where-      Quux1_0123456789876543210 = BazSym0-    type Quux1_0123456789876543210Sym0 :: a-    type family Quux1_0123456789876543210Sym0 @a :: a where-      Quux1_0123456789876543210Sym0 = Quux1_0123456789876543210+      Quux1_0123456789876543210 @a = BazSym0     class PBar1 a where       type family Quux1 :: a-      type Quux1 = Quux1_0123456789876543210Sym0+      type Quux1 = Quux1_0123456789876543210     class PBar2 a-    sQuux2 :: (SBar2 a => Sing (Quux2Sym0 :: a) :: Type)+    sQuux2 :: (SBar2 a => Sing (Quux2 :: a) :: Type)     sQuux2 = sBaz     class SFoo a where-      sBaz :: (Sing (BazSym0 :: a) :: Type)+      sBaz :: (Sing (Baz :: a) :: Type)     class SFoo a => SBar1 a where-      sQuux1 :: (Sing (Quux1Sym0 :: a) :: Type)+      sQuux1 :: (Sing (Quux1 :: a) :: Type)       default sQuux1 ::-                (((Quux1Sym0 :: a) ~ Quux1_0123456789876543210Sym0) =>-                 Sing (Quux1Sym0 :: a) :: Type)+                (((Quux1 :: a) ~ Quux1_0123456789876543210) =>+                 Sing (Quux1 :: a) :: Type)       sQuux1 = sBaz     class SFoo a => SBar2 a
tests/compile-and-dump/Singletons/T176.golden view
@@ -22,34 +22,24 @@       baz2 :: a     quux2 :: Foo2 a => a -> a     quux2 x = (x `bar2` baz2)-    type family Case_0123456789876543210 arg_01234567898765432100123456789876543210 x0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 x _ = Baz1Sym0-    type family Lambda_0123456789876543210 x0123456789876543210 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 ())     type Quux2Sym1 :: a -> a@@ -60,7 +50,7 @@       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 ())     type Quux1Sym1 :: a -> a@@ -71,13 +61,13 @@       Quux2 x = Apply (Apply Bar2Sym0 x) Baz2Sym0     type Quux1 :: a -> a     type family Quux1 @a (a :: a) :: a where-      Quux1 x = Apply (Apply Bar1Sym0 x) (Apply Lambda_0123456789876543210Sym0 x)+      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 ())     type Bar1Sym1 :: forall a b. a -> (~>) ((~>) a b) b@@ -85,7 +75,7 @@       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 ())     type Bar1Sym2 :: forall a b. a -> (~>) a b -> b@@ -102,7 +92,7 @@       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 ())     type Bar2Sym1 :: forall a b. a -> (~>) b b@@ -110,7 +100,7 @@       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 ())     type Bar2Sym2 :: forall a b. a -> b -> b@@ -123,24 +113,16 @@       type family Bar2 (arg :: a) (arg :: b) :: b       type family Baz2 :: a     sQuux2 ::-      (forall (t :: a).-       SFoo2 a => Sing t -> Sing (Apply Quux2Sym0 t :: a) :: Type)+      (forall (t :: a). SFoo2 a => Sing t -> Sing (Quux2 t :: a) :: Type)     sQuux1 ::-      (forall (t :: a).-       SFoo1 a => Sing t -> Sing (Apply Quux1Sym0 t :: a) :: Type)+      (forall (t :: a). SFoo1 a => Sing t -> Sing (Quux1 t :: a) :: Type)     sQuux2 (sX :: Sing x)       = applySing (applySing (singFun2 @Bar2Sym0 sBar2) sX) sBaz2     sQuux1 (sX :: Sing x)       = applySing           (applySing (singFun2 @Bar1Sym0 sBar1) sX)           (singFun1-             @(Apply Lambda_0123456789876543210Sym0 x)-             (\ sArg_0123456789876543210-                -> case sArg_0123456789876543210 of-                     (_ :: Sing arg_0123456789876543210)-                       -> id-                            @(Sing (Case_0123456789876543210 arg_0123456789876543210 x arg_0123456789876543210))-                            (case sArg_0123456789876543210 of _ -> sBaz1)))+             @(LamCases_0123456789876543210Sym0 x) (\cases _ -> sBaz1))     instance SFoo2 a => SingI (Quux2Sym0 :: (~>) a a) where       sing = singFun1 @Quux2Sym0 sQuux2     instance SFoo1 a => SingI (Quux1Sym0 :: (~>) a a) where@@ -148,13 +130,13 @@     class SFoo1 a where       sBar1 ::         (forall (t :: a) (t :: (~>) a b).-         Sing t -> Sing t -> Sing (Apply (Apply Bar1Sym0 t) t :: b) :: Type)-      sBaz1 :: (Sing (Baz1Sym0 :: a) :: Type)+         Sing t -> Sing t -> Sing (Bar1 t t :: b) :: Type)+      sBaz1 :: (Sing (Baz1 :: a) :: Type)     class SFoo2 a where       sBar2 ::         (forall (t :: a) (t :: b).-         Sing t -> Sing t -> Sing (Apply (Apply Bar2Sym0 t) t :: b) :: Type)-      sBaz2 :: (Sing (Baz2Sym0 :: a) :: Type)+         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
tests/compile-and-dump/Singletons/T178.golden view
@@ -42,29 +42,8 @@       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 (<>@#@$)) EQSym0) NilSym0@@ -76,71 +55,17 @@       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)+      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,11 +92,6 @@       (%==) 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@@ -202,12 +117,6 @@       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@@ -234,13 +143,13 @@             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 Eq (SOcc (z :: Occ)) where       (==) _ _ = True
tests/compile-and-dump/Singletons/T183.golden view
@@ -59,148 +59,80 @@           g :: a -> b -> a           g y _ = y         in g x ()-    data Let0123456789876543210GSym0 a0123456789876543210+    data Let0123456789876543210GSym0 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)       where-        Let0123456789876543210GSym0KindInference :: SameKind (Apply Let0123456789876543210GSym0 arg) (Let0123456789876543210GSym1 arg) =>-                                                    Let0123456789876543210GSym0 a0123456789876543210-    type instance Apply Let0123456789876543210GSym0 a0123456789876543210 = Let0123456789876543210GSym1 a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210GSym0 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 ((,) Let0123456789876543210GSym0KindInference ())-    data Let0123456789876543210GSym1 a0123456789876543210 x0123456789876543210+    data Let0123456789876543210GSym1 a0123456789876543210 (x0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: a0123456789876543210) :: (~>) b0123456789876543210 a0123456789876543210       where-        Let0123456789876543210GSym1KindInference :: SameKind (Apply (Let0123456789876543210GSym1 a0123456789876543210) arg) (Let0123456789876543210GSym2 a0123456789876543210 arg) =>-                                                    Let0123456789876543210GSym1 a0123456789876543210 x0123456789876543210-    type instance Apply (Let0123456789876543210GSym1 a0123456789876543210) x0123456789876543210 = Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210GSym1 a0123456789876543210) 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 ((,) Let0123456789876543210GSym1KindInference ())-    data Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)-      where-        Let0123456789876543210GSym2KindInference :: SameKind (Apply (Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210) arg) (Let0123456789876543210GSym3 a0123456789876543210 x0123456789876543210 arg) =>-                                                    Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210 a0123456789876543210-    type instance Apply (Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210) a0123456789876543210 = Let0123456789876543210GSym3 a0123456789876543210 x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210GSym2KindInference ())-    data Let0123456789876543210GSym3 a0123456789876543210 x0123456789876543210 (a0123456789876543210 :: a0123456789876543210) :: (~>) b0123456789876543210 a0123456789876543210-      where-        Let0123456789876543210GSym3KindInference :: SameKind (Apply (Let0123456789876543210GSym3 a0123456789876543210 x0123456789876543210 a0123456789876543210) arg) (Let0123456789876543210GSym4 a0123456789876543210 x0123456789876543210 a0123456789876543210 arg) =>-                                                    Let0123456789876543210GSym3 a0123456789876543210 x0123456789876543210 a0123456789876543210 a0123456789876543210-    type instance Apply (Let0123456789876543210GSym3 a0123456789876543210 x0123456789876543210 a0123456789876543210) a0123456789876543210 = Let0123456789876543210G a0123456789876543210 x0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210GSym3 a0123456789876543210 x0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210GSym3KindInference ())-    type family Let0123456789876543210GSym4 a0123456789876543210 x0123456789876543210 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) :: a0123456789876543210 where-      Let0123456789876543210GSym4 a0123456789876543210 x0123456789876543210 a0123456789876543210 a0123456789876543210 = Let0123456789876543210G a0123456789876543210 x0123456789876543210 a0123456789876543210 a0123456789876543210-    type family Let0123456789876543210G a0123456789876543210 x0123456789876543210 (a :: a0123456789876543210) (a :: b) :: a0123456789876543210 where+    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-    data Let0123456789876543210XSym0 a0123456789876543210-      where-        Let0123456789876543210XSym0KindInference :: SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>-                                                    Let0123456789876543210XSym0 a0123456789876543210-    type instance Apply Let0123456789876543210XSym0 a0123456789876543210 = Let0123456789876543210XSym1 a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210XSym0KindInference ())-    data Let0123456789876543210XSym1 a0123456789876543210 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210XSym1KindInference :: SameKind (Apply (Let0123456789876543210XSym1 a0123456789876543210) arg) (Let0123456789876543210XSym2 a0123456789876543210 arg) =>-                                                    Let0123456789876543210XSym1 a0123456789876543210 wild_01234567898765432100123456789876543210-    type instance Apply (Let0123456789876543210XSym1 a0123456789876543210) wild_01234567898765432100123456789876543210 = Let0123456789876543210X a0123456789876543210 wild_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210XSym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210XSym1KindInference ())-    type family Let0123456789876543210XSym2 a0123456789876543210 wild_01234567898765432100123456789876543210 where-      Let0123456789876543210XSym2 a0123456789876543210 wild_01234567898765432100123456789876543210 = Let0123456789876543210X a0123456789876543210 wild_01234567898765432100123456789876543210-    type family Let0123456789876543210X a0123456789876543210 wild_01234567898765432100123456789876543210 where+    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-    data Let0123456789876543210XSym0 a0123456789876543210-      where-        Let0123456789876543210XSym0KindInference :: SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>-                                                    Let0123456789876543210XSym0 a0123456789876543210-    type instance Apply Let0123456789876543210XSym0 a0123456789876543210 = Let0123456789876543210X a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210XSym0KindInference ())-    type family Let0123456789876543210XSym1 a0123456789876543210 where-      Let0123456789876543210XSym1 a0123456789876543210 = Let0123456789876543210X a0123456789876543210+    type family Let0123456789876543210XSym0 a0123456789876543210 where+      Let0123456789876543210XSym0 a0123456789876543210 = Let0123456789876543210X a0123456789876543210     type family Let0123456789876543210X a0123456789876543210 where       Let0123456789876543210X a = NothingSym0 :: Maybe a-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 a0123456789876543210-      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-      suppressUnusedWarnings-        = snd-            ((,)-               Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a0123456789876543210 arg) =>-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210-    type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210) x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 a0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd-            ((,)-               Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference-               ())-    type family Let0123456789876543210Scrutinee_0123456789876543210Sym2 a0123456789876543210 x0123456789876543210 where-      Let0123456789876543210Scrutinee_0123456789876543210Sym2 a0123456789876543210 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 a0123456789876543210 x0123456789876543210-    type family Let0123456789876543210Scrutinee_0123456789876543210 a0123456789876543210 x0123456789876543210 where-      Let0123456789876543210Scrutinee_0123456789876543210 a x = x :: Maybe a-    type family Case_0123456789876543210 a0123456789876543210 x0123456789876543210 t where-      Case_0123456789876543210 a x ('Just (y :: a) :: Maybe a) = Apply JustSym0 (Apply JustSym0 (y :: a) :: Maybe a)-    type family Case_0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 '(x :: a,-                                                                               y :: b) = Apply (Apply Tuple2Sym0 (y :: b)) (x :: a)-    type family Lambda_0123456789876543210 a_01234567898765432100123456789876543210 arg_0123456789876543210 where-      Lambda_0123456789876543210 a_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 arg_0123456789876543210-    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210+    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 x0123456789876543210 where-      Let0123456789876543210Scrutinee_0123456789876543210 x = Apply JustSym0 x-    type family Case_0123456789876543210 x0123456789876543210 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 ())     type Foo9Sym1 :: a -> a@@ -211,7 +143,7 @@       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 ())     type Foo8Sym1 :: forall a. Maybe a -> Maybe a@@ -222,7 +154,7 @@       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 ())     type Foo7Sym1 :: a -> (~>) b a@@ -230,7 +162,7 @@       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 ())     type Foo7Sym2 :: a -> b -> a@@ -241,7 +173,7 @@       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 ())     type Foo6Sym1 :: Maybe (Maybe a) -> Maybe (Maybe a)@@ -252,7 +184,7 @@       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 ())     type Foo5Sym1 :: Maybe (Maybe a) -> Maybe (Maybe a)@@ -263,7 +195,8 @@       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 ())     type Foo4Sym1 :: (a, b) -> (b, a)@@ -275,7 +208,7 @@       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 ())     type Foo3Sym1 :: forall a. Maybe a -> a@@ -286,7 +219,7 @@       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 ())     type Foo2Sym1 :: forall a. Maybe a -> a@@ -297,7 +230,7 @@       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 ())     type Foo1Sym1 :: Maybe a -> a@@ -307,7 +240,7 @@       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 ())     type family GSym1 a0123456789876543210 where@@ -316,7 +249,7 @@       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 ())     type family F3Sym1 a0123456789876543210 where@@ -325,7 +258,7 @@       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 ())     type family F2Sym1 a0123456789876543210 where@@ -334,30 +267,30 @@       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 ())     type family F1Sym1 a0123456789876543210 where       F1Sym1 a0123456789876543210 = F1 a0123456789876543210     type Foo9 :: a -> a     type family Foo9 @a (a :: a) :: a where-      Foo9 (x :: a) = Apply (Apply (Let0123456789876543210GSym2 a x) x) Tuple0Sym0+      Foo9 (x :: a) = Apply (Apply (Let0123456789876543210GSym0 a x) x) Tuple0Sym0     type Foo8 :: forall a. Maybe a -> Maybe a     type family Foo8 @a (a :: Maybe a) :: Maybe a where-      Foo8 @a ('Just (wild_0123456789876543210 :: a) :: Maybe a :: Maybe a) = Let0123456789876543210XSym2 a wild_0123456789876543210-      Foo8 @a ('Nothing :: Maybe a :: Maybe a) = Let0123456789876543210XSym1 a+      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 @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 (a :: Maybe (Maybe a)) :: Maybe (Maybe a) where-      Foo6 ('Just x :: Maybe (Maybe a)) = Case_0123456789876543210 a x (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a x)+      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 (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 @b (a :: (a, b)) :: (b, a) where-      Foo4 a_0123456789876543210 = Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210+      Foo4 a_0123456789876543210 = Apply (LamCases_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210     type Foo3 :: forall a. Maybe a -> a     type family Foo3 @a (a :: Maybe a) :: a where       Foo3 @a ('Just x :: Maybe a) = x :: a@@ -368,172 +301,152 @@     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 (t :: a). Sing t -> Sing (Apply Foo9Sym0 t :: a) :: Type)+    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 (t :: a) (t :: b).-       Sing t -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: a) :: Type)+       Sing t -> Sing t -> Sing (Foo7 t t :: a) :: Type)     sFoo6 ::       (forall (t :: Maybe (Maybe a)).-       Sing t -> Sing (Apply Foo6Sym0 t :: Maybe (Maybe a)) :: Type)+       Sing t -> Sing (Foo6 t :: Maybe (Maybe a)) :: Type)     sFoo5 ::       (forall (t :: Maybe (Maybe a)).-       Sing t -> Sing (Apply Foo5Sym0 t :: Maybe (Maybe a)) :: Type)+       Sing t -> Sing (Foo5 t :: Maybe (Maybe a)) :: Type)     sFoo4 ::-      (forall (t :: (a, b)).-       Sing t -> Sing (Apply Foo4Sym0 t :: (b, a)) :: Type)-    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 (t :: Maybe a).-       Sing t -> Sing (Apply Foo1Sym0 t :: a) :: Type)-    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 (t :: a) (t :: b).-                    Sing t-                    -> Sing t-                       -> Sing (Apply (Apply (Let0123456789876543210GSym2 a x) t) t :: a) :: Type)-                 sG (sY :: Sing y) _ = sY-               in-                 applySing-                   (applySing (singFun2 @(Let0123456789876543210GSym2 a 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 @_ (Let0123456789876543210XSym2 a 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 @_ (Let0123456789876543210XSym1 a)-                 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_0123456789876543210Sym2 a x)-                 sScrutinee_0123456789876543210 = sX :: Sing (x :: Maybe a)-               in-                 id-                   @(Sing (Case_0123456789876543210 a x (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a x)))-                   (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)))))+             @(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     instance SingI (Foo8Sym0 :: (~>) (Maybe a) (Maybe a)) where
tests/compile-and-dump/Singletons/T184.golden view
@@ -25,247 +25,109 @@     cartProd xs ys = [(x, y) | x <- xs, y <- ys]     trues :: [Bool] -> [Bool]     trues xs = [x | x <- xs, x]-    type family Lambda_0123456789876543210 xs0123456789876543210 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 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 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 xs0123456789876543210 ys0123456789876543210 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 xs0123456789876543210 ys0123456789876543210 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 xs0123456789876543210 ys0123456789876543210 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_01234567898765432100123456789876543210 xs0123456789876543210 ys0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 xs ys '(x,-                                                               y) = Apply ReturnSym0 (Apply (Apply Tuple2Sym0 x) y)-    type family Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 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 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 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 ma0123456789876543210 mb0123456789876543210 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 ())     type TruesSym1 :: [Bool] -> [Bool]@@ -276,7 +138,8 @@       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 ())     type CartProdSym1 :: [a] -> (~>) [b] [(a, b)]@@ -285,7 +148,8 @@       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 ())     type CartProdSym2 :: [a] -> [b] -> [(a, b)]@@ -297,7 +161,8 @@       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 ())     type Zip'Sym1 :: [a] -> (~>) [b] [(a, b)]@@ -305,7 +170,8 @@       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 ())     type Zip'Sym2 :: [a] -> [b] -> [(a, b)]@@ -317,7 +183,7 @@       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 ())     type BoogieSym1 :: Maybe a -> (~>) (Maybe Bool) (Maybe a)@@ -325,7 +191,7 @@       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 ())     type BoogieSym2 :: Maybe a -> Maybe Bool -> Maybe a@@ -333,66 +199,55 @@       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 @b (a :: [a]) (a :: [b]) :: [(a, b)] where-      CartProd xs ys = Apply (Apply (>>=@#@$) xs) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)+      CartProd xs ys = Apply (Apply (>>=@#@$) xs) (LamCases_0123456789876543210Sym0 xs ys)     type Zip' :: [a] -> [b] -> [(a, b)]     type family Zip' @a @b (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)+      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 (a :: Maybe a) (a :: Maybe Bool) :: Maybe a where-      Boogie ma mb = Apply (Apply (>>=@#@$) ma) (Apply (Apply Lambda_0123456789876543210Sym0 ma) mb)+      Boogie ma mb = Apply (Apply (>>=@#@$) ma) (LamCases_0123456789876543210Sym0 ma mb)     sTrues ::-      (forall (t :: [Bool]).-       Sing t -> Sing (Apply TruesSym0 t :: [Bool]) :: Type)+      (forall (t :: [Bool]). Sing t -> Sing (Trues t :: [Bool]) :: Type)     sCartProd ::       (forall (t :: [a]) (t :: [b]).-       Sing t-       -> Sing t-          -> Sing (Apply (Apply CartProdSym0 t) t :: [(a, b)]) :: Type)+       Sing t -> Sing t -> Sing (CartProd t t :: [(a, b)]) :: Type)     sZip' ::       (forall (t :: [a]) (t :: [b]).-       Sing t-       -> Sing t -> Sing (Apply (Apply Zip'Sym0 t) t :: [(a, b)]) :: Type)+       Sing t -> Sing t -> Sing (Zip' t t :: [(a, b)]) :: Type)     sBoogie ::       (forall (t :: Maybe a) (t :: Maybe Bool).-       Sing t-       -> Sing t-          -> Sing (Apply (Apply BoogieSym0 t) t :: Maybe a) :: Type)+       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)))+             @(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)))))+             @(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@@ -403,50 +258,40 @@                    (applySing                       (applySing (singFun2 @(>>=@#@$) (%>>=)) sXs)                       (singFun1-                         @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)-                         (\ sX-                            -> case sX of-                                 (_ :: Sing x) -> applySing (singFun1 @ReturnSym0 sReturn) sX))))+                         @(LamCases_0123456789876543210Sym0 xs ys)+                         (\cases+                            (sX :: 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)))))+                      @(LamCases_0123456789876543210Sym0 xs ys)+                      (\cases+                         (sY :: 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))))+             @(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)))))+             @(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     instance SingI (CartProdSym0 :: (~>) [a] ((~>) [b] [(a, b)])) where
tests/compile-and-dump/Singletons/T187.golden view
@@ -11,78 +11,25 @@     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 {})+      (%~) x _ = Proved ((\case) x)     instance Eq (SEmpty (z :: Empty)) where       (==) _ _ = True     instance GHC.Internal.Data.Type.Equality.TestEquality (SEmpty :: Empty
tests/compile-and-dump/Singletons/T190.golden view
@@ -13,146 +13,50 @@     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 (<>@#@$)) 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+    instance POrd T where+      type Compare a a = Compare_0123456789876543210 a a+    type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Num.Natural.Natural) a_0123456789876543210 where+      LamCases_0123456789876543210 n 'True = TSym0+      LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"+    data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Num.Natural.Natural) a_01234567898765432100123456789876543210       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+        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 ((,) 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-    instance POrd T where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family Case_0123456789876543210 n0123456789876543210 t where-      Case_0123456789876543210 n 'True = TSym0-      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Num.Natural.Natural) a_01234567898765432100123456789876543210 where+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210     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-      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-      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+      ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0))     type FromEnum_0123456789876543210 :: T -> GHC.Num.Natural.Natural     type family FromEnum_0123456789876543210 (a :: T) :: GHC.Num.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 MinBound = MinBound_0123456789876543210+      type MaxBound = MaxBound_0123456789876543210     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       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,18 +64,8 @@       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@@ -179,39 +73,24 @@                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
tests/compile-and-dump/Singletons/T197.golden view
@@ -13,31 +13,30 @@       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 $$:@#@$+    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 $$:@#@$$+    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) :: Type)+       Sing t -> Sing t -> Sing (($$:) t t :: Bool) :: Type)     (%$$:) _ _ = SFalse     instance SingI (($$:@#@$) :: (~>) Bool ((~>) Bool Bool)) where       sing = singFun2 @($$:@#@$) (%$$:)
tests/compile-and-dump/Singletons/T197b.golden view
@@ -14,7 +14,7 @@       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 ((,) (::*:@#@$###) ())     type (:*:@#@$$) :: forall a b. a -> (~>) b ((:*:) a b)@@ -22,7 +22,7 @@       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 ((,) (::*:@#@$$###) ())     type (:*:@#@$$$) :: forall a b. a -> b -> (:*:) a b@@ -33,24 +33,24 @@       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`+    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`+    infixr 9 type `MkPairSym1`     type MkPairSym2 :: forall a b. a -> b -> Pair a b     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).@@ -60,8 +60,8 @@       type Demote ((:*:) a b) = (:*:) (Demote a) (Demote 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).@@ -71,8 +71,8 @@       type Demote (Pair a b) = Pair (Demote a) (Demote 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
tests/compile-and-dump/Singletons/T200.golden view
@@ -23,7 +23,7 @@       where         (::$$:@#@$###) :: SameKind (Apply (:$$:@#@$) arg) ((:$$:@#@$$) arg) =>                           (:$$:@#@$) a0123456789876543210-    type instance Apply (:$$:@#@$) a0123456789876543210 = (:$$:@#@$$) a0123456789876543210+    type instance Apply @ErrorMessage @((~>) ErrorMessage ErrorMessage) (:$$:@#@$) a0123456789876543210 = (:$$:@#@$$) a0123456789876543210     instance SuppressUnusedWarnings (:$$:@#@$) where       suppressUnusedWarnings = snd ((,) (::$$:@#@$###) ())     type (:$$:@#@$$) :: ErrorMessage -> (~>) ErrorMessage ErrorMessage@@ -31,7 +31,7 @@       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 ((,) (::$$:@#@$$###) ())     type (:$$:@#@$$$) :: ErrorMessage -> ErrorMessage -> ErrorMessage@@ -42,7 +42,7 @@       where         (::<>:@#@$###) :: SameKind (Apply (:<>:@#@$) arg) ((:<>:@#@$$) arg) =>                           (:<>:@#@$) a0123456789876543210-    type instance Apply (:<>:@#@$) a0123456789876543210 = (:<>:@#@$$) a0123456789876543210+    type instance Apply @ErrorMessage @((~>) ErrorMessage ErrorMessage) (:<>:@#@$) a0123456789876543210 = (:<>:@#@$$) a0123456789876543210     instance SuppressUnusedWarnings (:<>:@#@$) where       suppressUnusedWarnings = snd ((,) (::<>:@#@$###) ())     type (:<>:@#@$$) :: ErrorMessage -> (~>) ErrorMessage ErrorMessage@@ -50,7 +50,7 @@       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 ((,) (::<>:@#@$$###) ())     type (:<>:@#@$$$) :: ErrorMessage -> ErrorMessage -> ErrorMessage@@ -61,7 +61,7 @@       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 ())     type EMSym1 :: [Bool] -> ErrorMessage@@ -72,7 +72,7 @@       where         (:<>:@#@$###) :: SameKind (Apply (<>:@#@$) arg) ((<>:@#@$$) arg) =>                          (<>:@#@$) a0123456789876543210-    type instance Apply (<>:@#@$) a0123456789876543210 = (<>:@#@$$) a0123456789876543210+    type instance Apply @ErrorMessage @((~>) ErrorMessage ErrorMessage) (<>:@#@$) a0123456789876543210 = (<>:@#@$$) a0123456789876543210     instance SuppressUnusedWarnings (<>:@#@$) where       suppressUnusedWarnings = snd ((,) (:<>:@#@$###) ())     type (<>:@#@$$) :: ErrorMessage -> (~>) ErrorMessage ErrorMessage@@ -80,7 +80,7 @@       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 ((,) (:<>:@#@$$###) ())     type (<>:@#@$$$) :: ErrorMessage -> ErrorMessage -> ErrorMessage@@ -91,7 +91,7 @@       where         (:$$:@#@$###) :: SameKind (Apply ($$:@#@$) arg) (($$:@#@$$) arg) =>                          ($$:@#@$) a0123456789876543210-    type instance Apply ($$:@#@$) a0123456789876543210 = ($$:@#@$$) a0123456789876543210+    type instance Apply @ErrorMessage @((~>) ErrorMessage ErrorMessage) ($$:@#@$) a0123456789876543210 = ($$:@#@$$) a0123456789876543210     instance SuppressUnusedWarnings ($$:@#@$) where       suppressUnusedWarnings = snd ((,) (:$$:@#@$###) ())     type ($$:@#@$$) :: ErrorMessage -> (~>) ErrorMessage ErrorMessage@@ -99,7 +99,7 @@       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 ((,) (:$$:@#@$$###) ())     type ($$:@#@$$$) :: ErrorMessage -> ErrorMessage -> ErrorMessage@@ -113,14 +113,10 @@       ($$:) x y = Apply (Apply (:$$:@#@$) x) y     (%<>:) ::       (forall (t :: ErrorMessage) (t :: ErrorMessage).-       Sing t-       -> Sing t-          -> Sing (Apply (Apply (<>:@#@$) t) t :: ErrorMessage) :: Type)+       Sing t -> Sing t -> Sing ((<>:) t t :: ErrorMessage) :: Type)     (%$$:) ::       (forall (t :: ErrorMessage) (t :: ErrorMessage).-       Sing t-       -> Sing t-          -> Sing (Apply (Apply ($$:@#@$) t) t :: ErrorMessage) :: Type)+       Sing t -> Sing t -> Sing (($$:) t t :: ErrorMessage) :: Type)     (%<>:) (sX :: Sing x) (sY :: Sing y)       = applySing (applySing (singFun2 @(:<>:@#@$) (:%<>:)) sX) sY     (%$$:) (sX :: Sing x) (sY :: Sing y)@@ -161,23 +157,17 @@       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
tests/compile-and-dump/Singletons/T204.golden view
@@ -20,7 +20,7 @@       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 ((,) (::%@#@$###) ())     type (:%@#@$$) :: forall a. a -> (~>) a (Ratio1 a)@@ -28,7 +28,7 @@       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 ((,) (::%@#@$$###) ())     type (:%@#@$$$) :: forall a. a -> a -> Ratio1 a@@ -39,7 +39,7 @@       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 ((,) (::%%@#@$###) ())     type (:%%@#@$$) :: forall a. a -> (~>) a (Ratio2 a)@@ -47,7 +47,7 @@       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 ((,) (::%%@#@$$###) ())     type (:%%@#@$$$) :: forall a. a -> a -> Ratio2 a@@ -62,8 +62,8 @@       type Demote (Ratio1 a) = Ratio1 (Demote a)       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)     data SRatio2 :: forall a. Ratio2 a -> GHC.Types.Type       where         (:^%%) :: forall a (n :: a) (n :: a).@@ -73,8 +73,8 @@       type Demote (Ratio2 a) = Ratio2 (Demote a)       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     instance SingI n => SingI1 ((:%) (n :: a)) where
tests/compile-and-dump/Singletons/T209.golden view
@@ -25,7 +25,7 @@       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 ())     type MSym1 :: a -> (~>) b ((~>) Bool Bool)@@ -33,7 +33,7 @@       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 ())     type MSym2 :: a -> b -> (~>) Bool Bool@@ -41,7 +41,7 @@       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 ())     type MSym3 :: a -> b -> Bool -> Bool@@ -55,10 +55,7 @@     instance PC a (Maybe a)     sM ::       (forall (t :: a) (t :: b) (t :: Bool).-       Sing t-       -> Sing t-          -> Sing t-             -> Sing (Apply (Apply (Apply MSym0 t) t) t :: Bool) :: Type)+       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
tests/compile-and-dump/Singletons/T216.golden view
@@ -5,14 +5,14 @@       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 ())     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 ())     type family MyProxySym2 (k0123456789876543210 :: Type) (e0123456789876543210 :: k0123456789876543210) :: Type where@@ -21,21 +21,21 @@       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 ())     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 ())     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 ())     type family SymmetrySym3 (a0123456789876543210 :: t0123456789876543210) (y0123456789876543210 :: t0123456789876543210) (e0123456789876543210 :: (:~:) a0123456789876543210 y0123456789876543210) :: Type where
tests/compile-and-dump/Singletons/T229.golden view
@@ -10,7 +10,7 @@       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 ())     type US___fooSym1 :: Bool -> Bool@@ -20,8 +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) :: Type)+      (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
tests/compile-and-dump/Singletons/T249.golden view
@@ -12,7 +12,7 @@       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 ())     type MkFoo1Sym1 :: forall a. a -> Foo1 a@@ -23,7 +23,7 @@       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 ())     type MkFoo2Sym1 :: x -> Foo2 x@@ -34,7 +34,7 @@       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 ())     type MkFoo3Sym1 :: forall x. x -> Foo3 x@@ -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,7 +71,8 @@       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
tests/compile-and-dump/Singletons/T271.golden view
@@ -19,7 +19,7 @@       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 ())     type ConstantSym1 :: forall (a :: Type) (b :: Type). a@@ -31,128 +31,36 @@       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 ())     type IdentitySym1 :: a -> Identity a     type family IdentitySym1 @a (a0123456789876543210 :: a) :: Identity a where       IdentitySym1 a0123456789876543210 = Identity a0123456789876543210-    type TFHelper_0123456789876543210 :: Constant a b-                                         -> Constant a b -> Bool+    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 (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 @a @b (a0123456789876543210 :: Constant a b) (a0123456789876543210 :: Constant a b) :: Bool where-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+      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 (==) 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 (Constant a_0123456789876543210) (Constant b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) 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 @a @b (a0123456789876543210 :: Constant a b) (a0123456789876543210 :: Constant a b) :: Ordering where-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+      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 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 (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 @a (a0123456789876543210 :: Identity a) (a0123456789876543210 :: Identity a) :: Bool where-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+      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 (==) 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 (Identity a_0123456789876543210) (Identity b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 (<>@#@$)) 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 @a (a0123456789876543210 :: Identity a) (a0123456789876543210 :: Identity a) :: Ordering where-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+      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@@ -163,8 +71,8 @@       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).@@ -174,14 +82,9 @@       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))@@ -189,11 +92,6 @@             (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))@@ -209,11 +107,6 @@                      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))@@ -221,11 +114,6 @@             (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))@@ -242,10 +130,10 @@                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 =>@@ -260,10 +148,10 @@         = 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 =>
tests/compile-and-dump/Singletons/T287.golden view
@@ -15,7 +15,7 @@       where         (:<<>>@#@$###) :: SameKind (Apply (<<>>@#@$) arg) ((<<>>@#@$$) arg) =>                           (<<>>@#@$) a0123456789876543210-    type instance Apply (<<>>@#@$) a0123456789876543210 = (<<>>@#@$$) a0123456789876543210+    type instance Apply @a @((~>) a a) (<<>>@#@$) a0123456789876543210 = (<<>>@#@$$) a0123456789876543210     instance SuppressUnusedWarnings (<<>>@#@$) where       suppressUnusedWarnings = snd ((,) (:<<>>@#@$###) ())     type (<<>>@#@$$) :: forall a. a -> (~>) a a@@ -23,7 +23,7 @@       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 ((,) (:<<>>@#@$$###) ())     type (<<>>@#@$$$) :: forall a. a -> a -> a@@ -31,83 +31,37 @@       (<<>>@#@$$$) a0123456789876543210 a0123456789876543210 = (<<>>) a0123456789876543210 a0123456789876543210     class PS a where       type family (<<>>) (arg :: a) (arg :: a) :: a-    type family Lambda_0123456789876543210 f0123456789876543210 g0123456789876543210 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+    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-        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+        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 ((,) 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+        = 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 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)-      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 b-                                             -> (~>) a b -> (~>) a b-    type family TFHelper_0123456789876543210Sym2 @a @b (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: (~>) a b) :: (~>) a b where-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+      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) :: Type)+         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) :: Type)       (%<<>>) (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))+            @(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 @(<<>>@#@$) (%<<>>)     instance (SS a, SingI d) =>
tests/compile-and-dump/Singletons/T29.golden view
@@ -22,7 +22,7 @@       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 ())     type BanSym1 :: Bool -> Bool@@ -33,7 +33,7 @@       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 ())     type BazSym1 :: Bool -> Bool@@ -44,7 +44,7 @@       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 ())     type BarSym1 :: Bool -> Bool@@ -55,7 +55,7 @@       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 ())     type FooSym1 :: Bool -> Bool@@ -74,17 +74,13 @@     type family Foo (a :: Bool) :: Bool where       Foo x = Apply (Apply ($@#@$) NotSym0) x     sBan ::-      (forall (t :: Bool).-       Sing t -> Sing (Apply BanSym0 t :: Bool) :: Type)+      (forall (t :: Bool). Sing t -> Sing (Ban t :: Bool) :: Type)     sBaz ::-      (forall (t :: Bool).-       Sing t -> Sing (Apply BazSym0 t :: Bool) :: Type)+      (forall (t :: Bool). Sing t -> Sing (Baz t :: Bool) :: Type)     sBar ::-      (forall (t :: Bool).-       Sing t -> Sing (Apply BarSym0 t :: Bool) :: Type)+      (forall (t :: Bool). Sing t -> Sing (Bar t :: Bool) :: Type)     sFoo ::-      (forall (t :: Bool).-       Sing t -> Sing (Apply FooSym0 t :: Bool) :: Type)+      (forall (t :: Bool). Sing t -> Sing (Foo t :: Bool) :: Type)     sBan (sX :: Sing x)       = applySing           (applySing
tests/compile-and-dump/Singletons/T296.golden view
@@ -23,36 +23,20 @@     type MyProxySym0 :: forall (a :: Type). MyProxy a     type family MyProxySym0 @(a :: Type) :: MyProxy a where       MyProxySym0 = MyProxy-    data Let0123456789876543210ZSym0 a0123456789876543210-      where-        Let0123456789876543210ZSym0KindInference :: SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>-                                                    Let0123456789876543210ZSym0 a0123456789876543210-    type instance Apply Let0123456789876543210ZSym0 a0123456789876543210 = Let0123456789876543210Z a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210ZSym0KindInference ())-    type family Let0123456789876543210ZSym1 a0123456789876543210 :: MyProxy a0123456789876543210 where-      Let0123456789876543210ZSym1 a0123456789876543210 = Let0123456789876543210Z a0123456789876543210+    type family Let0123456789876543210ZSym0 a0123456789876543210 :: MyProxy a0123456789876543210 where+      Let0123456789876543210ZSym0 a0123456789876543210 = Let0123456789876543210Z a0123456789876543210     type family Let0123456789876543210Z a0123456789876543210 :: MyProxy a0123456789876543210 where       Let0123456789876543210Z a = MyProxySym0-    data Let0123456789876543210XSym0 a0123456789876543210-      where-        Let0123456789876543210XSym0KindInference :: SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>-                                                    Let0123456789876543210XSym0 a0123456789876543210-    type instance Apply Let0123456789876543210XSym0 a0123456789876543210 = Let0123456789876543210X a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210XSym0KindInference ())-    type family Let0123456789876543210XSym1 a0123456789876543210 where-      Let0123456789876543210XSym1 a0123456789876543210 = Let0123456789876543210X a0123456789876543210+    type family Let0123456789876543210XSym0 a0123456789876543210 where+      Let0123456789876543210XSym0 a0123456789876543210 = Let0123456789876543210X a0123456789876543210     type family Let0123456789876543210X a0123456789876543210 where-      Let0123456789876543210X a = Let0123456789876543210ZSym1 a+      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 ())     type FSym1 :: forall a. MyProxy a -> MyProxy a@@ -60,16 +44,14 @@       FSym1 a0123456789876543210 = F a0123456789876543210     type F :: forall a. MyProxy a -> MyProxy a     type family F @a (a :: MyProxy a) :: MyProxy a where-      F @a (MyProxy :: MyProxy a) = Let0123456789876543210XSym1 a-    sF ::-      forall a (t :: MyProxy a). Sing t-                                 -> Sing (Apply FSym0 t :: MyProxy a)+      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 @_ (Let0123456789876543210XSym1 a)+          sX :: Sing @_ (Let0123456789876543210X a)           sX             = let-                sZ :: (Sing (Let0123456789876543210ZSym1 a :: MyProxy a) :: Type)+                sZ :: (Sing (Let0123456789876543210Z a :: MyProxy a) :: Type)                 sZ = SMyProxy               in sZ         in sX
tests/compile-and-dump/Singletons/T297.golden view
@@ -35,20 +35,20 @@       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 ())     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 :: (Sing (Let0123456789876543210ZSym0 :: MyProxy a) :: Type)+                sZ :: (Sing (Let0123456789876543210Z :: MyProxy a) :: Type)                 sZ = SMyProxy               in sZ         in sX
tests/compile-and-dump/Singletons/T312.golden view
@@ -24,7 +24,7 @@       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 ())     type BarSym1 :: forall a b. a -> (~>) b b@@ -32,7 +32,7 @@       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 ())     type BarSym2 :: forall a b. a -> b -> b@@ -43,7 +43,7 @@       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 ())     type BazSym1 :: forall a b. a -> (~>) b b@@ -51,118 +51,57 @@       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 ())     type BazSym2 :: forall a b. a -> b -> b     type family BazSym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where       BazSym2 a0123456789876543210 a0123456789876543210 = Baz a0123456789876543210 a0123456789876543210-    type Bar_0123456789876543210 :: 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 _ 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 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where-      Bar_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Bar_0123456789876543210 a0123456789876543210 a0123456789876543210-    data Let0123456789876543210HSym0 a_01234567898765432100123456789876543210+      Bar_0123456789876543210 @a @b (_ :: a) (x :: b) = x+    data Let0123456789876543210HSym0 a0123456789876543210 b0123456789876543210 (a_01234567898765432100123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) :: (~>) c0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)       where-        Let0123456789876543210HSym0KindInference :: SameKind (Apply Let0123456789876543210HSym0 arg) (Let0123456789876543210HSym1 arg) =>-                                                    Let0123456789876543210HSym0 a_01234567898765432100123456789876543210-    type instance Apply Let0123456789876543210HSym0 a_01234567898765432100123456789876543210 = Let0123456789876543210HSym1 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210HSym0 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 ((,) Let0123456789876543210HSym0KindInference ())-    data Let0123456789876543210HSym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    data Let0123456789876543210HSym1 a0123456789876543210 b0123456789876543210 (a_01234567898765432100123456789876543210 :: a0123456789876543210) (a_01234567898765432100123456789876543210 :: b0123456789876543210) (a0123456789876543210 :: c0123456789876543210) :: (~>) b0123456789876543210 b0123456789876543210       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+        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 ((,) 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_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 (a :: c) (a :: b) :: b where-      Let0123456789876543210H a_0123456789876543210 a_0123456789876543210 (_ :: c) (x :: b) = x-    type Baz_0123456789876543210 :: a -> b -> b+    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_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)-      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-      suppressUnusedWarnings-        = snd ((,) Baz_0123456789876543210Sym0KindInference ())-    type Baz_0123456789876543210Sym1 :: a -> (~>) b b-    data Baz_0123456789876543210Sym1 (a0123456789876543210 :: a) :: (~>) b b-      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-      suppressUnusedWarnings-        = snd ((,) Baz_0123456789876543210Sym1KindInference ())-    type Baz_0123456789876543210Sym2 :: a -> b -> b-    type family Baz_0123456789876543210Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where-      Baz_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Baz_0123456789876543210 a0123456789876543210 a0123456789876543210+      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 (t :: a) (t :: b).-         Sing t -> Sing t -> Sing (Apply (Apply BarSym0 t) t :: b) :: Type)+         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 (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) :: Type)+                 ((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)@@ -173,11 +112,11 @@                   sH ::                     forall c (t :: c) (t :: b). Sing t                                                 -> Sing t-                                                   -> Sing (Apply (Apply (Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210) t) t :: b)+                                                   -> Sing (Let0123456789876543210H a b a_0123456789876543210 a_0123456789876543210 t t :: b)                   sH _ (sX :: Sing x) = sX                 in                   singFun2-                    @(Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210)+                    @(Let0123456789876543210HSym0 a b a_0123456789876543210 a_0123456789876543210)                     sH)                sA_0123456789876543210)             sA_0123456789876543210
tests/compile-and-dump/Singletons/T313.golden view
@@ -26,7 +26,7 @@       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 ())     type family PFoo1Sym1 a0123456789876543210 where@@ -35,7 +35,7 @@       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 ())     type family PFoo3Sym1 a0123456789876543210 where@@ -44,7 +44,7 @@       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 ())     type family PFoo2Sym1 (a0123456789876543210 :: Type) :: Type where@@ -53,7 +53,7 @@       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 ())     type family PFoo4Sym1 (a0123456789876543210 :: Type) where@@ -88,7 +88,7 @@       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 ())     type family SFoo1Sym1 a0123456789876543210 where@@ -97,7 +97,7 @@       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 ())     type family SFoo3Sym1 a0123456789876543210 where@@ -106,7 +106,7 @@       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 ())     type family SFoo2Sym1 (a0123456789876543210 :: Type) :: Type where@@ -115,7 +115,7 @@       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 ())     type family SFoo4Sym1 (a0123456789876543210 :: Type) where
tests/compile-and-dump/Singletons/T316.golden view
@@ -8,7 +8,7 @@       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 ())@@ -18,7 +18,7 @@       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 ())@@ -28,7 +28,7 @@       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 ())
tests/compile-and-dump/Singletons/T322.golden view
@@ -13,31 +13,30 @@       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 !@#@$+    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 !@#@$$+    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) :: Type)+       Sing t -> Sing t -> Sing ((!) t t :: Bool) :: Type)     (%!)       (sA_0123456789876543210 :: Sing a_0123456789876543210)       (sA_0123456789876543210 :: Sing a_0123456789876543210)
tests/compile-and-dump/Singletons/T326.golden view
@@ -1,68 +1,67 @@ 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+    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 (<%>@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where+    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+    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 (<%%>@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where+    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) :: Type)+         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 @(<%%>@#@$) (%<%%>)     instance (SC2 a, SingI d) =>
tests/compile-and-dump/Singletons/T33.golden view
@@ -10,7 +10,8 @@       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 ())     type FooSym1 :: (Bool, Bool) -> ()@@ -21,12 +22,10 @@     type family Foo (a :: (Bool, Bool)) :: () where       Foo '(_, _) = Tuple0Sym0     sFoo ::-      (forall (t :: (Bool, Bool)).-       Sing t -> Sing (Apply FooSym0 t :: ()) :: Type)+      (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: [GHC-39584]     Lazy pattern converted into regular pattern during singleton generation.   |@@ -38,3 +37,4 @@   | 6 | $(singletons [d|   |  ^^^^^^^^^^^^^^^...+
tests/compile-and-dump/Singletons/T332.golden view
@@ -16,7 +16,7 @@       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 ())     type FSym1 :: Foo -> ()@@ -43,7 +43,7 @@       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 ())     type BSym1 :: Bar -> ()@@ -52,8 +52,7 @@     type B :: Bar -> ()     type family B (a :: Bar) :: () where       B MkBar = Tuple0Sym0-    sB ::-      (forall (t :: Bar). Sing t -> Sing (Apply BSym0 t :: ()) :: Type)+    sB :: (forall (t :: Bar). Sing t -> Sing (B t :: ()) :: Type)     sB SMkBar = STuple0     instance SingI (BSym0 :: (~>) Bar ()) where       sing = singFun1 @BSym0 sB
tests/compile-and-dump/Singletons/T342.golden view
@@ -11,7 +11,7 @@       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 ())     type family MyIdSym1 a0123456789876543210 where
tests/compile-and-dump/Singletons/T353.golden view
@@ -11,21 +11,21 @@       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 ())     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 ())     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 ())     type family SymmetrySym3 (a0123456789876543210 :: Proxy t0123456789876543210) (y0123456789876543210 :: Proxy t0123456789876543210) (e0123456789876543210 :: (:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) :: Type where@@ -33,7 +33,7 @@ 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 g p))@@ -41,10 +41,10 @@       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+    type MkProdSym1 :: forall {k :: Type}                               (f :: k -> Type)                               (g :: k -> Type)                               (p :: k). f p -> (~>) (g p) (Prod f g p)@@ -52,40 +52,44 @@       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+    type MkProdSym2 :: forall {k :: Type}                               (f :: k -> Type)                               (g :: k -> Type)                               (p :: k). f p -> g p -> Prod f g p-    type family MkProdSym2 @k @(f :: k -> Type) @(g :: k-                                                       -> Type) @(p :: k) (a0123456789876543210 :: f p) (a0123456789876543210 :: g p) :: Prod f g p where+    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 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 b)+    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 b-    type family MkFooSym2 @k @k @(a :: k) @(b :: k) (a0123456789876543210 :: Proxy a) (a0123456789876543210 :: Proxy b) :: Foo a b where+    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
@@ -35,7 +35,7 @@       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 ())     type Method2aSym1 :: forall b a. b -> a@@ -46,7 +46,7 @@       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 ())     type Method2bSym1 :: forall b a. b -> a@@ -55,62 +55,30 @@     class PC2 a where       type family Method2a (arg :: b) :: a       type family Method2b (arg :: b) :: a-    type Method1_0123456789876543210 :: [a]+    type Method1_0123456789876543210 :: forall a. [a]     type family Method1_0123456789876543210 @a :: [a] where-      Method1_0123456789876543210 = NilSym0-    type Method1_0123456789876543210Sym0 :: [a]-    type family Method1_0123456789876543210Sym0 @a :: [a] where-      Method1_0123456789876543210Sym0 = Method1_0123456789876543210+      Method1_0123456789876543210 @a = NilSym0     instance PC1 [] where-      type Method1 = Method1_0123456789876543210Sym0-    type Method2a_0123456789876543210 :: b -> [a]-    type family Method2a_0123456789876543210 @b @a (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 @b @a (a0123456789876543210 :: b) :: [a] where-      Method2a_0123456789876543210Sym1 a0123456789876543210 = Method2a_0123456789876543210 a0123456789876543210-    type Method2b_0123456789876543210 :: b -> [a]-    type family Method2b_0123456789876543210 @b @a (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 @b @a (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 :: (Sing (Method1Sym0 :: f a) :: Type)+      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 :: (Sing (Method1Sym0 :: [a]) :: Type)+      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
tests/compile-and-dump/Singletons/T367.golden view
@@ -8,7 +8,7 @@       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 ())@@ -17,7 +17,7 @@       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 ())@@ -29,8 +29,7 @@       Const' x _ = x     sConst' ::       (forall (t :: a) (t :: b).-       Sing t-       -> Sing t -> Sing (Apply (Apply Const'Sym0 t) t :: a) :: Type)+       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'
tests/compile-and-dump/Singletons/T371.golden view
@@ -21,7 +21,7 @@       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@@ -35,92 +35,26 @@       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 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 ShowsPrec_0123456789876543210 :: forall a. GHC.Num.Natural.Natural+                                                    -> X a -> GHC.Types.Symbol -> GHC.Types.Symbol     type family ShowsPrec_0123456789876543210 @a (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 @a (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+      ShowsPrec_0123456789876543210 @a (_ :: GHC.Num.Natural.Natural) (X1 :: X a) (a_0123456789876543210 :: GHC.Types.Symbol) = Apply (Apply ShowStringSym0 "X1") a_0123456789876543210+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Num.Natural.Natural) (X2 arg_0123456789876543210 :: X a) (a_0123456789876543210 :: GHC.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 ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a+    type ShowsPrec_0123456789876543210 :: forall a. GHC.Num.Natural.Natural+                                                    -> Y a -> GHC.Types.Symbol -> GHC.Types.Symbol     type family ShowsPrec_0123456789876543210 @a (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 @a (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+      ShowsPrec_0123456789876543210 @a (_ :: GHC.Num.Natural.Natural) (Y1 :: Y a) (a_0123456789876543210 :: GHC.Types.Symbol) = Apply (Apply ShowStringSym0 "Y1") a_0123456789876543210+      ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Num.Natural.Natural) (Y2 arg_0123456789876543210 :: Y a) (a_0123456789876543210 :: GHC.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)@@ -132,7 +66,8 @@       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)@@ -144,16 +79,9 @@       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@@ -185,14 +113,6 @@                      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
tests/compile-and-dump/Singletons/T376.golden view
@@ -10,7 +10,7 @@       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 ())     type FSym1 :: (~>) () () -> (~>) () ()@@ -18,7 +18,7 @@       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 ())     type FSym2 :: (~>) () () -> () -> ()@@ -29,7 +29,7 @@       F g a_0123456789876543210 = Apply (g :: (~>) () ()) a_0123456789876543210     sF ::       (forall (t :: (~>) () ()) (t :: ()).-       Sing t -> Sing t -> Sing (Apply (Apply FSym0 t) t :: ()) :: Type)+       Sing t -> Sing t -> Sing (F t t :: ()) :: Type)     sF       (sG :: Sing g)       (sA_0123456789876543210 :: Sing a_0123456789876543210)
tests/compile-and-dump/Singletons/T378a.golden view
@@ -35,7 +35,7 @@       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 ())     type ConstBASym1 :: forall b a. a -> (~>) b a@@ -43,7 +43,7 @@       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 ())     type ConstBASym2 :: forall b a. a -> b -> a@@ -54,7 +54,7 @@       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
tests/compile-and-dump/Singletons/T378b.golden view
@@ -23,16 +23,8 @@     natMinus Zero _ = Zero     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 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)@@ -40,7 +32,7 @@       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 ())     type NatMinusSym1 :: Nat -> (~>) Nat Nat@@ -48,7 +40,7 @@       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 ())     type NatMinusSym2 :: Nat -> Nat -> Nat@@ -59,7 +51,7 @@       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 ())     type FSym1 :: forall b a. a -> (~>) b ()@@ -67,7 +59,7 @@       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 ())     type FSym2 :: forall b a. a -> b -> ()@@ -77,7 +69,7 @@     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 @b @a (a :: a) (a :: b) :: () where       F @b @a (_ :: a) (_ :: b) = Tuple0Sym0@@ -85,11 +77,10 @@     class PC x y     sNatMinus ::       (forall (t :: Nat) (t :: Nat).-       Sing t-       -> Sing t -> Sing (Apply (Apply NatMinusSym0 t) t :: Nat) :: Type)+       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@@ -97,8 +88,7 @@       (SSucc (sWild_0123456789876543210 :: Sing wild_0123456789876543210))       SZero       = let-          sA ::-            Sing @_ (Let0123456789876543210ASym1 wild_0123456789876543210)+          sA :: Sing @_ (Let0123456789876543210A wild_0123456789876543210)           sA = applySing (singFun1 @SuccSym0 SSucc) sWild_0123456789876543210         in sA     sF _ _ = STuple0@@ -121,7 +111,7 @@     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/T402.golden view
@@ -6,7 +6,7 @@       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 ())     type family AnyOfKindSym1 (k0123456789876543210 :: Type) :: k0123456789876543210 where
tests/compile-and-dump/Singletons/T410.golden view
@@ -15,7 +15,7 @@       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 ())@@ -24,7 +24,7 @@       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 ())@@ -36,26 +36,5 @@     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,130 +30,128 @@       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`+    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`+    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`+    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`+    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`+    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`+    infixr 5 type `MkD1Sym1`     type MkD1Sym2 :: forall a b. a -> b -> D1 a b     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`+    infixr 5 type `D1BSym0`     type D1BSym1 :: forall a b. D1 a b -> b     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`+    infixr 5 type `D1ASym0`     type D1ASym1 :: forall a b. D1 a b -> a     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 @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 @b (a :: D1 a b) :: a where       D1A @a @b (MkD1 field _ :: D1 a b) = field-    infixr 5 `D1B`-    infixr 5 `D1A`-    infix 5 `PC1`+    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`+    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`+    infix 6 type `M1Sym1`     type M1Sym2 :: forall a b. a -> b -> Bool     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@@ -169,14 +167,13 @@       type Demote (D1 a b) = D1 (Demote a) (Demote 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) :: Type)-      infix 6 `sM1`+         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     instance SingI n => SingI1 (MkD1 (n :: a)) where@@ -201,41 +198,40 @@ 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+    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 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: Bool where+    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) :: Type)+         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     instance (SC2 a b, SingI d) =>@@ -248,77 +244,77 @@       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`+    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`+    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`+    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`+    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 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`+    infixr 5 type `MkD2Sym0`     type MkD2Sym1 :: forall (a :: Type) (b :: Type). a                                                      -> (~>) 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`+    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`+    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 b -> b@@ -329,7 +325,7 @@       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 b -> a@@ -343,10 +339,10 @@       D2A @a @b ('MkD2 field _ :: D2 a b) = field     sD2B ::       forall (a :: Type) (b :: Type) (t :: D2 a b). Sing t-                                                    -> Sing (Apply D2BSym0 t :: b)+                                                    -> Sing (D2B t :: b)     sD2A ::       forall (a :: Type) (b :: Type) (t :: D2 a b). Sing t-                                                    -> Sing (Apply D2ASym0 t :: a)+                                                    -> Sing (D2A t :: a)     sD2B (SMkD2 _ (sField :: Sing field)) = sField     sD2A (SMkD2 (sField :: Sing field) _) = sField     instance SingI (D2BSym0 :: (~>) (D2 a b) b) where@@ -363,11 +359,11 @@       type Demote (D2 a b) = D2 (Demote a) (Demote 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
tests/compile-and-dump/Singletons/T414.golden view
@@ -20,14 +20,14 @@       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 ())     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 ())     type family T1Sym2 (a0123456789876543210 :: Bool) b0123456789876543210 where@@ -37,14 +37,14 @@       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 ())     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 ())     type family T2Sym2 a0123456789876543210 b0123456789876543210 where@@ -55,7 +55,7 @@       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 ())     type T3Sym1 :: Bool -> (~>) Type Type@@ -63,7 +63,7 @@       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 ())     type T3Sym2 :: Bool -> Type -> Type
tests/compile-and-dump/Singletons/T433.golden view
@@ -75,112 +75,48 @@       where           g :: b -> a -> b           g y _ = y-    data Let0123456789876543210GSym0 x0123456789876543210+    data Let0123456789876543210GSym0 (x0123456789876543210 :: a0123456789876543210) :: (~>) b0123456789876543210 ((~>) a0123456789876543210 b0123456789876543210)       where-        Let0123456789876543210GSym0KindInference :: SameKind (Apply Let0123456789876543210GSym0 arg) (Let0123456789876543210GSym1 arg) =>-                                                    Let0123456789876543210GSym0 x0123456789876543210-    type instance Apply Let0123456789876543210GSym0 x0123456789876543210 = Let0123456789876543210GSym1 x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210GSym0 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 :: (~>) b0123456789876543210 ((~>) a0123456789876543210 b0123456789876543210)+    data Let0123456789876543210GSym1 (x0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) :: (~>) a0123456789876543210 b0123456789876543210       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+        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 ())-    data Let0123456789876543210GSym2 x0123456789876543210 (a0123456789876543210 :: b0123456789876543210) :: (~>) a0123456789876543210 b0123456789876543210-      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 :: b0123456789876543210) (a0123456789876543210 :: a0123456789876543210) :: b0123456789876543210 where-      Let0123456789876543210GSym3 x0123456789876543210 a0123456789876543210 a0123456789876543210 = Let0123456789876543210G x0123456789876543210 a0123456789876543210 a0123456789876543210-    type family Let0123456789876543210G x0123456789876543210 (a :: b) (a :: a) :: b where+    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-    data Let0123456789876543210GSym0 b0123456789876543210-      where-        Let0123456789876543210GSym0KindInference :: SameKind (Apply Let0123456789876543210GSym0 arg) (Let0123456789876543210GSym1 arg) =>-                                                    Let0123456789876543210GSym0 b0123456789876543210-    type instance Apply Let0123456789876543210GSym0 b0123456789876543210 = Let0123456789876543210GSym1 b0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210GSym0 where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210GSym0KindInference ())-    data Let0123456789876543210GSym1 b0123456789876543210 x0123456789876543210-      where-        Let0123456789876543210GSym1KindInference :: SameKind (Apply (Let0123456789876543210GSym1 b0123456789876543210) arg) (Let0123456789876543210GSym2 b0123456789876543210 arg) =>-                                                    Let0123456789876543210GSym1 b0123456789876543210 x0123456789876543210-    type instance Apply (Let0123456789876543210GSym1 b0123456789876543210) x0123456789876543210 = Let0123456789876543210G b0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210GSym1 b0123456789876543210) where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210GSym1KindInference ())-    type family Let0123456789876543210GSym2 b0123456789876543210 x0123456789876543210 where-      Let0123456789876543210GSym2 b0123456789876543210 x0123456789876543210 = Let0123456789876543210G b0123456789876543210 x0123456789876543210-    type family Let0123456789876543210G b0123456789876543210 x0123456789876543210 where+    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-    data Let0123456789876543210GSym0 b0123456789876543210-      where-        Let0123456789876543210GSym0KindInference :: SameKind (Apply Let0123456789876543210GSym0 arg) (Let0123456789876543210GSym1 arg) =>-                                                    Let0123456789876543210GSym0 b0123456789876543210-    type instance Apply Let0123456789876543210GSym0 b0123456789876543210 = Let0123456789876543210GSym1 b0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210GSym0 where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210GSym0KindInference ())-    data Let0123456789876543210GSym1 b0123456789876543210 x0123456789876543210-      where-        Let0123456789876543210GSym1KindInference :: SameKind (Apply (Let0123456789876543210GSym1 b0123456789876543210) arg) (Let0123456789876543210GSym2 b0123456789876543210 arg) =>-                                                    Let0123456789876543210GSym1 b0123456789876543210 x0123456789876543210-    type instance Apply (Let0123456789876543210GSym1 b0123456789876543210) x0123456789876543210 = Let0123456789876543210G b0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210GSym1 b0123456789876543210) where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210GSym1KindInference ())-    type family Let0123456789876543210GSym2 b0123456789876543210 x0123456789876543210 where-      Let0123456789876543210GSym2 b0123456789876543210 x0123456789876543210 = Let0123456789876543210G b0123456789876543210 x0123456789876543210-    type family Let0123456789876543210G b0123456789876543210 x0123456789876543210 where+    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-    data Let0123456789876543210GSym0 a0123456789876543210-      where-        Let0123456789876543210GSym0KindInference :: SameKind (Apply Let0123456789876543210GSym0 arg) (Let0123456789876543210GSym1 arg) =>-                                                    Let0123456789876543210GSym0 a0123456789876543210-    type instance Apply Let0123456789876543210GSym0 a0123456789876543210 = Let0123456789876543210GSym1 a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210GSym0 where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210GSym0KindInference ())-    data Let0123456789876543210GSym1 a0123456789876543210 a_01234567898765432100123456789876543210-      where-        Let0123456789876543210GSym1KindInference :: SameKind (Apply (Let0123456789876543210GSym1 a0123456789876543210) arg) (Let0123456789876543210GSym2 a0123456789876543210 arg) =>-                                                    Let0123456789876543210GSym1 a0123456789876543210 a_01234567898765432100123456789876543210-    type instance Apply (Let0123456789876543210GSym1 a0123456789876543210) a_01234567898765432100123456789876543210 = Let0123456789876543210G a0123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210GSym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210GSym1KindInference ())-    type family Let0123456789876543210GSym2 a0123456789876543210 a_01234567898765432100123456789876543210 where-      Let0123456789876543210GSym2 a0123456789876543210 a_01234567898765432100123456789876543210 = Let0123456789876543210G a0123456789876543210 a_01234567898765432100123456789876543210-    type family Let0123456789876543210G a0123456789876543210 a_01234567898765432100123456789876543210 where+    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+    data Let0123456789876543210GSym0 local0123456789876543210 :: (~>) a0123456789876543210 a0123456789876543210       where-        Let0123456789876543210GSym0KindInference :: SameKind (Apply Let0123456789876543210GSym0 arg) (Let0123456789876543210GSym1 arg) =>-                                                    Let0123456789876543210GSym0 local0123456789876543210-    type instance Apply Let0123456789876543210GSym0 local0123456789876543210 = Let0123456789876543210GSym1 local0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210GSym0 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 ())-    data Let0123456789876543210GSym1 local0123456789876543210 :: (~>) a0123456789876543210 a0123456789876543210-      where-        Let0123456789876543210GSym1KindInference :: SameKind (Apply (Let0123456789876543210GSym1 local0123456789876543210) arg) (Let0123456789876543210GSym2 local0123456789876543210 arg) =>-                                                    Let0123456789876543210GSym1 local0123456789876543210 a0123456789876543210-    type instance Apply (Let0123456789876543210GSym1 local0123456789876543210) a0123456789876543210 = Let0123456789876543210G local0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210GSym1 local0123456789876543210) where-      suppressUnusedWarnings-        = snd ((,) Let0123456789876543210GSym1KindInference ())-    type family Let0123456789876543210GSym2 local0123456789876543210 (a0123456789876543210 :: a0123456789876543210) :: a0123456789876543210 where-      Let0123456789876543210GSym2 local0123456789876543210 a0123456789876543210 = Let0123456789876543210G local0123456789876543210 a0123456789876543210+    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@@ -188,7 +124,7 @@       where         Id8Sym0KindInference :: SameKind (Apply Id8Sym0 arg) (Id8Sym1 arg) =>                                 Id8Sym0 a0123456789876543210-    type instance Apply Id8Sym0 a0123456789876543210 = Id8 a0123456789876543210+    type instance Apply @a @a Id8Sym0 a0123456789876543210 = Id8 a0123456789876543210     instance SuppressUnusedWarnings Id8Sym0 where       suppressUnusedWarnings = snd ((,) Id8Sym0KindInference ())     type Id8Sym1 :: a -> a@@ -198,7 +134,7 @@       where         Id7Sym0KindInference :: SameKind (Apply Id7Sym0 arg) (Id7Sym1 arg) =>                                 Id7Sym0 a0123456789876543210-    type instance Apply Id7Sym0 a0123456789876543210 = Id7 a0123456789876543210+    type instance Apply @_ @_ Id7Sym0 a0123456789876543210 = Id7 a0123456789876543210     instance SuppressUnusedWarnings Id7Sym0 where       suppressUnusedWarnings = snd ((,) Id7Sym0KindInference ())     type family Id7Sym1 a0123456789876543210 where@@ -208,7 +144,7 @@       where         Id6Sym0KindInference :: SameKind (Apply Id6Sym0 arg) (Id6Sym1 arg) =>                                 Id6Sym0 a0123456789876543210-    type instance Apply Id6Sym0 a0123456789876543210 = Id6 a0123456789876543210+    type instance Apply @a @a Id6Sym0 a0123456789876543210 = Id6 a0123456789876543210     instance SuppressUnusedWarnings Id6Sym0 where       suppressUnusedWarnings = snd ((,) Id6Sym0KindInference ())     type Id6Sym1 :: a -> a@@ -219,7 +155,7 @@       where         Id5Sym0KindInference :: SameKind (Apply Id5Sym0 arg) (Id5Sym1 arg) =>                                 Id5Sym0 a0123456789876543210-    type instance Apply Id5Sym0 a0123456789876543210 = Id5 a0123456789876543210+    type instance Apply @a @a Id5Sym0 a0123456789876543210 = Id5 a0123456789876543210     instance SuppressUnusedWarnings Id5Sym0 where       suppressUnusedWarnings = snd ((,) Id5Sym0KindInference ())     type Id5Sym1 :: forall a. a -> a@@ -230,7 +166,7 @@       where         Id4Sym0KindInference :: SameKind (Apply Id4Sym0 arg) (Id4Sym1 arg) =>                                 Id4Sym0 a0123456789876543210-    type instance Apply Id4Sym0 a0123456789876543210 = Id4 a0123456789876543210+    type instance Apply @a @a Id4Sym0 a0123456789876543210 = Id4 a0123456789876543210     instance SuppressUnusedWarnings Id4Sym0 where       suppressUnusedWarnings = snd ((,) Id4Sym0KindInference ())     type Id4Sym1 :: forall a. a -> a@@ -241,7 +177,7 @@       where         Id3Sym0KindInference :: SameKind (Apply Id3Sym0 arg) (Id3Sym1 arg) =>                                 Id3Sym0 a0123456789876543210-    type instance Apply Id3Sym0 a0123456789876543210 = Id3 a0123456789876543210+    type instance Apply @a @a Id3Sym0 a0123456789876543210 = Id3 a0123456789876543210     instance SuppressUnusedWarnings Id3Sym0 where       suppressUnusedWarnings = snd ((,) Id3Sym0KindInference ())     type Id3Sym1 :: a -> a@@ -252,7 +188,7 @@       where         Id2Sym0KindInference :: SameKind (Apply Id2Sym0 arg) (Id2Sym1 arg) =>                                 Id2Sym0 a0123456789876543210-    type instance Apply Id2Sym0 a0123456789876543210 = Id2 a0123456789876543210+    type instance Apply @a @a Id2Sym0 a0123456789876543210 = Id2 a0123456789876543210     instance SuppressUnusedWarnings Id2Sym0 where       suppressUnusedWarnings = snd ((,) Id2Sym0KindInference ())     type Id2Sym1 :: forall a. a -> a@@ -263,7 +199,7 @@       where         FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) =>                                 FooSym0 a0123456789876543210-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210+    type instance Apply @a @() FooSym0 a0123456789876543210 = Foo a0123456789876543210     instance SuppressUnusedWarnings FooSym0 where       suppressUnusedWarnings = snd ((,) FooSym0KindInference ())     type FooSym1 :: forall a. a -> ()@@ -273,7 +209,7 @@       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 ())     type family FSym1 a0123456789876543210 where@@ -283,7 +219,7 @@       where         Konst2Sym0KindInference :: SameKind (Apply Konst2Sym0 arg) (Konst2Sym1 arg) =>                                    Konst2Sym0 a0123456789876543210-    type instance Apply Konst2Sym0 a0123456789876543210 = Konst2Sym1 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@@ -291,7 +227,7 @@       where         Konst2Sym1KindInference :: SameKind (Apply (Konst2Sym1 a0123456789876543210) arg) (Konst2Sym2 a0123456789876543210 arg) =>                                    Konst2Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Konst2Sym1 a0123456789876543210) a0123456789876543210 = Konst2 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@@ -302,7 +238,7 @@       where         Konst1Sym0KindInference :: SameKind (Apply Konst1Sym0 arg) (Konst1Sym1 arg) =>                                    Konst1Sym0 a0123456789876543210-    type instance Apply Konst1Sym0 a0123456789876543210 = Konst1Sym1 a0123456789876543210+    type instance Apply @a @((~>) Bool a) Konst1Sym0 a0123456789876543210 = Konst1Sym1 a0123456789876543210     instance SuppressUnusedWarnings Konst1Sym0 where       suppressUnusedWarnings = snd ((,) Konst1Sym0KindInference ())     type Konst1Sym1 :: a -> (~>) Bool a@@ -310,7 +246,7 @@       where         Konst1Sym1KindInference :: SameKind (Apply (Konst1Sym1 a0123456789876543210) arg) (Konst1Sym2 a0123456789876543210 arg) =>                                    Konst1Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Konst1Sym1 a0123456789876543210) a0123456789876543210 = Konst1 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@@ -318,15 +254,15 @@       Konst1Sym2 a0123456789876543210 a0123456789876543210 = Konst1 a0123456789876543210 a0123456789876543210     type Id8 :: a -> a     type family Id8 @a (a :: a) :: a where-      Id8 x = Apply (Apply (Let0123456789876543210GSym1 x) x) TrueSym0+      Id8 x = Apply (Apply (Let0123456789876543210GSym0 x) x) TrueSym0     type family Id7 a where-      Id7 (x :: b) = Let0123456789876543210GSym2 b x+      Id7 (x :: b) = Let0123456789876543210GSym0 b x     type Id6 :: a -> a     type family Id6 @a (a :: a) :: a where-      Id6 (x :: b) = Let0123456789876543210GSym2 b x+      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 (Let0123456789876543210GSym2 a a_0123456789876543210) a_0123456789876543210+      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)@@ -340,7 +276,7 @@     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 = Let0123456789876543210GSym1 local+      F local = Let0123456789876543210GSym0 local     type Konst2 :: a -> Maybe Bool -> a     type family Konst2 @a (a :: a) (a :: Maybe Bool) :: a where       Konst2 x _ = x
tests/compile-and-dump/Singletons/T443.golden view
@@ -20,7 +20,7 @@       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 ())     type SSym1 :: Nat -> Nat@@ -34,7 +34,7 @@       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 ((,) (::>@#@$###) ())     type (:>@#@$$) :: a -> (~>) (Vec n a) (Vec (S n) a)@@ -42,7 +42,7 @@       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 ((,) (::>@#@$$###) ())     type (:>@#@$$$) :: a -> Vec n a -> Vec (S n) a@@ -53,7 +53,7 @@       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 ())     type TailSym1 :: Vec (S n) a -> Vec n a@@ -64,7 +64,7 @@       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 ())     type HeadSym1 :: Vec (S n) a -> a@@ -78,10 +78,9 @@       Head ((:>) field _) = field     sTail ::       (forall (t :: Vec (S n) a).-       Sing t -> Sing (Apply TailSym0 t :: Vec n a) :: Type)+       Sing t -> Sing (Tail t :: Vec n a) :: Type)     sHead ::-      (forall (t :: Vec (S n) a).-       Sing t -> Sing (Apply HeadSym0 t :: a) :: Type)+      (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
tests/compile-and-dump/Singletons/T445.golden view
@@ -6,7 +6,7 @@       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 ())     type LitSym1 :: Natural -> Nat@@ -21,32 +21,24 @@           filterEvenGt7 :: [Nat] -> [Nat]           filterEvenGt7 = filter (\ x -> evenb x && x > lit 7) |]   ======>-    type family Lambda_0123456789876543210 a_01234567898765432100123456789876543210 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 ())@@ -58,7 +50,7 @@       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 ())     type EvenbSym1 :: Nat -> Bool@@ -66,7 +58,7 @@       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,7 +41,7 @@       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 ())     type PMkMessageSym1 :: Symbol -> PMessage@@ -57,8 +57,8 @@       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@@ -73,7 +73,7 @@       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 ())@@ -82,7 +82,7 @@       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 ())@@ -94,18 +94,17 @@       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) :: Type)+       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     instance SingI d =>@@ -123,7 +122,7 @@       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 ())     type PMkFunctionSym1 :: forall (a :: Type) (b :: Type). (~>) a b@@ -142,8 +141,8 @@       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@@ -160,7 +159,7 @@       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 ())@@ -170,7 +169,7 @@       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 ())@@ -185,17 +184,17 @@     sComposeFunction ::       (forall (t :: PFunction b c) (t :: PFunction a b).        Sing t-       -> Sing t-          -> Sing (Apply (Apply ComposeFunctionSym0 t) t :: PFunction a c) :: Type)+       -> 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     instance SingI d =>
tests/compile-and-dump/Singletons/T470.golden view
@@ -19,7 +19,7 @@       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 ())     type MkT1Sym1 :: a -> T a@@ -30,7 +30,7 @@       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 ())     type MkT2Sym1 :: Void -> T a@@ -41,7 +41,7 @@       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 ())     type MkSSym1 :: Bool -> S@@ -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,7 +70,8 @@       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
tests/compile-and-dump/Singletons/T487.golden view
@@ -25,7 +25,7 @@       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 ())     type ConsExSym1 :: Char -> Symbol@@ -49,13 +49,12 @@     type ExprEx :: Char     type family ExprEx :: Char where       ExprEx = 'a'-    sCharToNatEx :: (Sing (CharToNatExSym0 :: Natural) :: Type)-    sNatToCharEx :: (Sing (NatToCharExSym0 :: Char) :: Type)-    sUnconsEx :: (Sing (UnconsExSym0 :: Maybe (Char, Symbol)) :: Type)+    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) :: Type)-    sExprEx :: (Sing (ExprExSym0 :: Char) :: Type)+      (forall (t :: Char). Sing t -> Sing (ConsEx t :: Symbol) :: Type)+    sExprEx :: (Sing (ExprEx :: Char) :: Type)     sCharToNatEx       = applySing (singFun1 @CharToNatSym0 sCharToNat) (sing :: Sing 'a')     sNatToCharEx
tests/compile-and-dump/Singletons/T489.golden view
@@ -18,7 +18,7 @@       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 ())     type FlurmpSym1 :: Maybe () -> ()@@ -29,7 +29,7 @@       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 ())     type BlahSym1 :: Maybe a -> [a]@@ -44,11 +44,9 @@       Blah ('Just @a x) = Apply (Apply (:@#@$) (x :: a)) NilSym0       Blah ('Nothing @a) = NilSym0 :: [a]     sFlurmp ::-      (forall (t :: Maybe ()).-       Sing t -> Sing (Apply FlurmpSym0 t :: ()) :: Type)+      (forall (t :: Maybe ()). Sing t -> Sing (Flurmp t :: ()) :: Type)     sBlah ::-      (forall (t :: Maybe a).-       Sing t -> Sing (Apply BlahSym0 t :: [a]) :: Type)+      (forall (t :: Maybe a). Sing t -> Sing (Blah t :: [a]) :: Type)     sFlurmp (SNothing @_) = STuple0     sFlurmp (SJust STuple0) = STuple0     sBlah (SJust @a (sX :: Sing x))
tests/compile-and-dump/Singletons/T536.golden view
@@ -27,7 +27,7 @@       where         PMkMessageSym0KindInference :: Data.Singletons.SameKind (Data.Singletons.Apply PMkMessageSym0 arg) (PMkMessageSym1 arg) =>                                        PMkMessageSym0 a0123456789876543210-    type instance Data.Singletons.Apply PMkMessageSym0 a0123456789876543210 = 'PMkMessage 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 ())@@ -46,10 +46,10 @@         = MkMessage (Data.Singletons.fromSing b)       Data.Singletons.toSing         (MkMessage (b :: Data.Singletons.Demote Symbol))-        = case  Data.Singletons.toSing b :: Data.Singletons.SomeSing Symbol-          of-            Data.Singletons.SomeSing c-              -> Data.Singletons.SomeSing (SMkMessage c)+        = (\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@@ -66,7 +66,7 @@     type Hello :: PMessage     type family Hello :: PMessage where       Hello = Data.Singletons.Apply PMkMessageSym0 (FromString "hello")-    sHello :: (Data.Singletons.Sing (HelloSym0 :: PMessage) :: Type)+    sHello :: (Data.Singletons.Sing (Hello :: PMessage) :: Type)     sHello       = Data.Singletons.applySing           (Data.Singletons.singFun1 @PMkMessageSym0 SMkMessage)@@ -75,16 +75,16 @@     instance Data.Singletons.Decide.SDecide Text =>              Data.Singletons.Decide.SDecide PMessage where       (Data.Singletons.Decide.%~) (SMkMessage a) (SMkMessage b)-        = case (Data.Singletons.Decide.%~) a b of-            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-                   (\ refl-                      -> case refl of-                           GHC.Internal.Data.Type.Equality.Refl-                             -> contra GHC.Internal.Data.Type.Equality.Refl)+        = (\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 =>
tests/compile-and-dump/Singletons/T54.golden view
@@ -5,29 +5,24 @@   ======>     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 e0123456789876543210 where-      Let0123456789876543210Scrutinee_0123456789876543210 e = Apply (Apply (:@#@$) NotSym0) NilSym0-    type family Case_0123456789876543210 e0123456789876543210 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 ())     type GSym1 :: Bool -> Bool@@ -35,23 +30,17 @@       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) :: Type)+      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+             (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
tests/compile-and-dump/Singletons/T555.golden view
@@ -20,31 +20,8 @@       TFHelper_0123456789876543210 Location Quaternion = FalseSym0       TFHelper_0123456789876543210 Quaternion Location = FalseSym0       TFHelper_0123456789876543210 Quaternion Quaternion = TrueSym0-    type TFHelper_0123456789876543210Sym0 :: (~>) MyPropKind ((~>) MyPropKind Bool)-    data TFHelper_0123456789876543210Sym0 :: (~>) MyPropKind ((~>) MyPropKind 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 :: MyPropKind-                                             -> (~>) MyPropKind Bool-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: MyPropKind) :: (~>) MyPropKind 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 :: MyPropKind-                                             -> MyPropKind -> Bool-    type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: MyPropKind) (a0123456789876543210 :: MyPropKind) :: Bool where-      TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210     instance PEq MyPropKind where-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a+      type (==) a a = TFHelper_0123456789876543210 a a     type Compare_0123456789876543210 :: MyPropKind                                         -> MyPropKind -> Ordering     type family Compare_0123456789876543210 (a :: MyPropKind) (a :: MyPropKind) :: Ordering where@@ -52,71 +29,15 @@       Compare_0123456789876543210 Quaternion Quaternion = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0       Compare_0123456789876543210 Location Quaternion = LTSym0       Compare_0123456789876543210 Quaternion Location = GTSym0-    type Compare_0123456789876543210Sym0 :: (~>) MyPropKind ((~>) MyPropKind Ordering)-    data Compare_0123456789876543210Sym0 :: (~>) MyPropKind ((~>) MyPropKind 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 :: MyPropKind-                                            -> (~>) MyPropKind Ordering-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: MyPropKind) :: (~>) MyPropKind 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 :: MyPropKind-                                            -> MyPropKind -> Ordering-    type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: MyPropKind) (a0123456789876543210 :: MyPropKind) :: Ordering where-      Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210     instance POrd MyPropKind where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+      type Compare a a = Compare_0123456789876543210 a a     type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural                                           -> MyPropKind -> Symbol -> Symbol     type family ShowsPrec_0123456789876543210 (a :: GHC.Num.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-    type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) MyPropKind ((~>) Symbol Symbol))-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) MyPropKind ((~>) 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-                                              -> (~>) MyPropKind ((~>) Symbol Symbol)-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) MyPropKind ((~>) 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-                                              -> MyPropKind -> (~>) Symbol Symbol-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: MyPropKind) :: (~>) 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-                                              -> MyPropKind -> Symbol -> Symbol-    type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: MyPropKind) (a0123456789876543210 :: Symbol) :: Symbol where-      ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210     instance PShow MyPropKind 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 SMyPropKind :: MyPropKind -> Type       where         SLocation :: SMyPropKind (Location :: MyPropKind)@@ -129,21 +50,11 @@       toSing Location = SomeSing SLocation       toSing Quaternion = SomeSing SQuaternion     instance SEq MyPropKind where-      (%==) ::-        forall (t1 :: MyPropKind) (t2 :: MyPropKind). Sing t1-                                                      -> Sing t2-                                                         -> Sing (Apply (Apply ((==@#@$) :: TyFun MyPropKind ((~>) MyPropKind Bool)-                                                                                            -> Type) t1) t2)       (%==) SLocation SLocation = STrue       (%==) SLocation SQuaternion = SFalse       (%==) SQuaternion SLocation = SFalse       (%==) SQuaternion SQuaternion = STrue     instance SOrd MyPropKind where-      sCompare ::-        forall (t1 :: MyPropKind) (t2 :: MyPropKind). Sing t1-                                                      -> Sing t2-                                                         -> Sing (Apply (Apply (CompareSym0 :: TyFun MyPropKind ((~>) MyPropKind Ordering)-                                                                                               -> Type) t1) t2)       sCompare SLocation SLocation         = applySing             (applySing@@ -159,14 +70,6 @@       sCompare SLocation SQuaternion = SLT       sCompare SQuaternion SLocation = SGT     instance SShow MyPropKind where-      sShowsPrec ::-        forall (t1 :: GHC.Num.Natural.Natural)-               (t2 :: MyPropKind)-               (t3 :: Symbol). Sing t1-                               -> Sing t2-                                  -> Sing t3-                                     -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) MyPropKind ((~>) Symbol Symbol))-                                                                                    -> Type) t1) t2) t3)       sShowsPrec         _         SLocation@@ -185,8 +88,8 @@             sA_0123456789876543210     instance SDecide MyPropKind where       (%~) SLocation SLocation = Proved Refl-      (%~) SLocation SQuaternion = Disproved (\ x -> case x of {})-      (%~) SQuaternion SLocation = Disproved (\ x -> case x of {})+      (%~) SLocation SQuaternion = Disproved (\case)+      (%~) SQuaternion SLocation = Disproved (\case)       (%~) SQuaternion SQuaternion = Proved Refl     instance Eq (SMyPropKind (z :: MyPropKind)) where       (==) _ _ = True
tests/compile-and-dump/Singletons/T563.golden view
@@ -11,7 +11,7 @@       where         MkFooSym0KindInference :: SameKind (Apply MkFooSym0 arg) (MkFooSym1 arg) =>                                   MkFooSym0 a0123456789876543210-    type instance Apply MkFooSym0 a0123456789876543210 = MkFoo a0123456789876543210+    type instance Apply @Bool @Foo MkFooSym0 a0123456789876543210 = MkFoo a0123456789876543210     instance SuppressUnusedWarnings MkFooSym0 where       suppressUnusedWarnings = snd ((,) MkFooSym0KindInference ())     type MkFooSym1 :: Bool -> Foo@@ -25,8 +25,8 @@       type Demote Foo = Foo       fromSing (SMkFoo b) = MkFoo (fromSing b)       toSing (MkFoo (b :: Demote Bool))-        = case toSing b :: SomeSing Bool of-            SomeSing c -> SomeSing (SMkFoo c)+        = (\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@@ -43,7 +43,7 @@       where         UnFoo'Sym0KindInference :: SameKind (Apply UnFoo'Sym0 arg) (UnFoo'Sym1 arg) =>                                    UnFoo'Sym0 a0123456789876543210-    type instance Apply UnFoo'Sym0 a0123456789876543210 = UnFoo' 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@@ -53,13 +53,11 @@     type family UnFoo' (a :: Foo) :: Bool where       UnFoo' a_0123456789876543210 = Apply UnFooSym0 a_0123456789876543210     sUnFoo' ::-      (forall (t :: Foo).-       Sing t -> Sing (Apply UnFoo'Sym0 t :: Bool) :: Type)+      (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:@@ -69,3 +67,4 @@    | 13 | $(singletonsOnly [d|    |  ^^^^^^^^^^^^^^^^^^^...+
+ 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
@@ -19,29 +19,32 @@     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 x p. D1 x p-    type family MkD1Sym0 @x @p :: D1 x p where+    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. D2 x p-    type family MkD2Sym0 @j @(x :: j) @p :: D2 x p where+    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 x (p :: Proxy x). D3 x p-    type family MkD3Sym0 @x @(p :: Proxy x) :: D3 x p where+    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 x p. SD1 (MkD1 :: D1 x p)+      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. SD2 (MkD2 :: D2 x p)+      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 x (p :: Proxy x). SD3 (MkD3 :: D3 x p)+      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
tests/compile-and-dump/Singletons/T571.golden view
@@ -10,7 +10,7 @@       where         FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) =>                               FSym0 a0123456789876543210-    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210+    type instance Apply @a @a FSym0 a0123456789876543210 = F a0123456789876543210     instance SuppressUnusedWarnings FSym0 where       suppressUnusedWarnings = snd ((,) FSym0KindInference ())     type FSym1 :: a -> a@@ -19,8 +19,7 @@     type F :: a -> a     type family F @a (a :: a) :: a where       F x = x-    sF ::-      (forall (t :: a). Sing t -> Sing (Apply FSym0 t :: a) :: Type)+    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@@ -36,7 +35,7 @@       where         GSym0KindInference :: SameKind (Apply GSym0 arg) (GSym1 arg) =>                               GSym0 a0123456789876543210-    type instance Apply GSym0 a0123456789876543210 = GSym1 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@@ -44,7 +43,7 @@       where         GSym1KindInference :: SameKind (Apply (GSym1 a0123456789876543210) arg) (GSym2 a0123456789876543210 arg) =>                               GSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (GSym1 a0123456789876543210) a0123456789876543210 = G 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@@ -55,7 +54,7 @@       G f x = Apply f x     sG ::       (forall (t :: (~>) a a) (t :: a).-       Sing t -> Sing t -> Sing (Apply (Apply GSym0 t) t :: a) :: Type)+       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
+ 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 C1 [a] where+            m1 :: forall b. [a] -> Maybe ([a], b)+            m1 _ = Nothing :: Maybe ([a], b)+          instance C2 (Maybe a) where+            m2 _ = Nothing :: Maybe (Maybe a)+          instance C2 [a] where+            m2 :: b -> Maybe [a]+            m2 _ = Nothing :: Maybe [a]+          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) |]+  ======>+    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
@@ -10,7 +10,7 @@       where         KonstSym0KindInference :: SameKind (Apply KonstSym0 arg) (KonstSym1 arg) =>                                   KonstSym0 a0123456789876543210-    type instance Apply KonstSym0 a0123456789876543210 = KonstSym1 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@@ -18,7 +18,7 @@       where         KonstSym1KindInference :: SameKind (Apply (KonstSym1 a0123456789876543210) arg) (KonstSym2 a0123456789876543210 arg) =>                                   KonstSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (KonstSym1 a0123456789876543210) a0123456789876543210 = Konst 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@@ -29,7 +29,7 @@       Konst @a (x :: a) (_ :: b) = x     sKonst ::       forall a {b} (t :: a) (t :: b). Sing t-                                      -> Sing t -> Sing (Apply (Apply KonstSym0 t) t :: a)+                                      -> Sing t -> Sing (Konst t t :: a)     sKonst (sX :: Sing x) _ = sX     instance SingI (KonstSym0 :: (~>) a ((~>) b a)) where       sing = singFun2 @KonstSym0 sKonst
tests/compile-and-dump/Singletons/T78.golden view
@@ -14,7 +14,7 @@       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 ())     type FooSym1 :: Maybe Bool -> Bool@@ -26,8 +26,7 @@       Foo ('Just 'True) = TrueSym0       Foo 'Nothing = FalseSym0     sFoo ::-      (forall (t :: Maybe Bool).-       Sing t -> Sing (Apply FooSym0 t :: Bool) :: Type)+      (forall (t :: Maybe Bool). Sing t -> Sing (Foo t :: Bool) :: Type)     sFoo (SJust SFalse) = SFalse     sFoo (SJust STrue) = STrue     sFoo SNothing = SFalse
tests/compile-and-dump/Singletons/T89.golden view
@@ -10,44 +10,28 @@     type FooSym0 :: Foo     type family FooSym0 :: Foo where       FooSym0 = Foo-    type family Case_0123456789876543210 n0123456789876543210 t where-      Case_0123456789876543210 n 'True = FooSym0-      Case_0123456789876543210 n 'False = Apply ErrorSym0 (FromString "toEnum: bad argument")-    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.Num.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.Num.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+        = snd ((,) LamCases_0123456789876543210Sym0KindInference ())+    type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Num.Natural.Natural) a_01234567898765432100123456789876543210 where+      LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210+    type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> Foo+    type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: Foo where+      ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0))     type FromEnum_0123456789876543210 :: Foo -> GHC.Num.Natural.Natural     type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Num.Natural.Natural where       FromEnum_0123456789876543210 Foo = FromInteger 0-    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 SFoo :: SFoo (Foo :: Foo)     type instance Sing @Foo = SFoo     instance SingKind Foo where@@ -55,25 +39,19 @@       fromSing SFoo = Foo       toSing Foo = SomeSing SFoo     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 -> SFoo-               SFalse-                 -> sError (sFromString (sing :: Sing "toEnum: bad argument")))+        = 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/TopLevelPatterns.golden view
@@ -16,7 +16,7 @@       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         = GHC.Internal.Data.Tuple.snd ((,) BarSym0KindInference ())@@ -25,7 +25,7 @@       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         = GHC.Internal.Data.Tuple.snd ((,) BarSym1KindInference ())@@ -52,10 +52,8 @@       type Demote Foo = Foo       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@@ -114,28 +112,116 @@     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_01234567898765432100123456789876543210 t where-      Case_0123456789876543210 a_0123456789876543210 '(_,-                                                       y_0123456789876543210) = y_0123456789876543210-    type family Case_0123456789876543210 a_01234567898765432100123456789876543210 t where-      Case_0123456789876543210 a_0123456789876543210 '(y_0123456789876543210,-                                                       _) = y_0123456789876543210-    type family Case_0123456789876543210 a_01234567898765432100123456789876543210 t where-      Case_0123456789876543210 a_0123456789876543210 '[_,-                                                       y_0123456789876543210] = y_0123456789876543210-    type family Case_0123456789876543210 a_01234567898765432100123456789876543210 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,7 +243,7 @@       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         = GHC.Internal.Data.Tuple.snd ((,) ISym0KindInference ())@@ -169,7 +255,7 @@       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         = GHC.Internal.Data.Tuple.snd ((,) HSym0KindInference ())@@ -183,7 +269,7 @@       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         = GHC.Internal.Data.Tuple.snd ((,) GSym0KindInference ())@@ -195,7 +281,7 @@       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         = GHC.Internal.Data.Tuple.snd ((,) FSym0KindInference ())@@ -211,7 +297,7 @@       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         = GHC.Internal.Data.Tuple.snd ((,) NotSym0KindInference ())@@ -223,7 +309,7 @@       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         = GHC.Internal.Data.Tuple.snd ((,) IdSym0KindInference ())@@ -235,34 +321,34 @@       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@@ -277,47 +363,42 @@     type Otherwise :: Bool     type family Otherwise :: Bool where       Otherwise = TrueSym0-    sM :: (Sing (MSym0 :: Bool) :: Type)-    sL :: (Sing (LSym0 :: Bool) :: Type)-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0-    sK :: (Sing (KSym0 :: Bool) :: Type)-    sJ :: (Sing (JSym0 :: Bool) :: Type)-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0-    sI ::-      (forall (t :: Bool).-       Sing t -> Sing (Apply ISym0 t :: Bool) :: Type)-    sH ::-      (forall (t :: Bool).-       Sing t -> Sing (Apply HSym0 t :: Bool) :: Type)-    sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0-    sG ::-      (forall (t :: Bool).-       Sing t -> Sing (Apply GSym0 t :: Bool) :: Type)-    sF ::-      (forall (t :: Bool).-       Sing t -> Sing (Apply FSym0 t :: Bool) :: Type)-    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) :: Type)-    sId ::-      (forall (t :: a). Sing t -> Sing (Apply IdSym0 t :: a) :: Type)-    sOtherwise :: (Sing (OtherwiseSym0 :: Bool) :: Type)+      (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.Internal.Base.id-          @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))-          (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.Internal.Base.id-          @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))-          (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@@ -329,36 +410,44 @@                 (applySing (singFun1 @IdSym0 sId) SFalse))              SNil)     sK-      = GHC.Internal.Base.id-          @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))-          (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.Internal.Base.id-          @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))-          (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)     sI (sA_0123456789876543210 :: Sing a_0123456789876543210)       = applySing-          (GHC.Internal.Base.id-             @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0))-             (case sX_0123456789876543210 of-                STuple2 _ (sY_0123456789876543210 :: Sing y_0123456789876543210)-                  -> sY_0123456789876543210))+          (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.Internal.Base.id-             @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0))-             (case sX_0123456789876543210 of-                STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _-                  -> sY_0123456789876543210))+          (applySing+             (singFun1+                @(LamCases_0123456789876543210Sym0 a_0123456789876543210)+                (\cases+                   (STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _)+                     -> sY_0123456789876543210))+             sX_0123456789876543210)           sA_0123456789876543210     sX_0123456789876543210       = applySing@@ -366,21 +455,26 @@           (singFun1 @GSym0 sG)     sG (sA_0123456789876543210 :: Sing a_0123456789876543210)       = applySing-          (GHC.Internal.Base.id-             @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0))-             (case sX_0123456789876543210 of-                SCons _-                      (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) SNil)-                  -> sY_0123456789876543210))+          (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.Internal.Base.id-             @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0))-             (case sX_0123456789876543210 of-                SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)-                      (SCons _ SNil)-                  -> sY_0123456789876543210))+          (applySing+             (singFun1+                @(LamCases_0123456789876543210Sym0 a_0123456789876543210)+                (\cases+                   (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)+                          (SCons _ SNil))+                     -> sY_0123456789876543210))+             sX_0123456789876543210)           sA_0123456789876543210     sX_0123456789876543210       = applySing
tests/compile-and-dump/Singletons/TypeAbstractions.golden view
@@ -57,14 +57,14 @@       where         TSSym0KindInference :: SameKind (Apply TSSym0 arg) (TSSym1 arg) =>                                TSSym0 e0123456789876543210-    type instance Apply TSSym0 e0123456789876543210 = TSSym1 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 (TSSym1 e0123456789876543210) e0123456789876543210 = TS 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@@ -73,14 +73,14 @@       where         TFSym0KindInference :: SameKind (Apply TFSym0 arg) (TFSym1 arg) =>                                TFSym0 e0123456789876543210-    type instance Apply TFSym0 e0123456789876543210 = TFSym1 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 (TFSym1 e0123456789876543210) e0123456789876543210 = TF 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@@ -93,7 +93,7 @@       where         MkD1Sym0KindInference :: SameKind (Apply MkD1Sym0 arg) (MkD1Sym1 arg) =>                                  MkD1Sym0 a0123456789876543210-    type instance Apply MkD1Sym0 a0123456789876543210 = MkD1Sym1 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@@ -102,7 +102,7 @@       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 @(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@@ -117,7 +117,7 @@       where         MkD2Sym0KindInference :: SameKind (Apply MkD2Sym0 arg) (MkD2Sym1 arg) =>                                  MkD2Sym0 a0123456789876543210-    type instance Apply MkD2Sym0 a0123456789876543210 = MkD2Sym1 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@@ -126,7 +126,7 @@       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 @(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@@ -141,7 +141,7 @@       where         MkD3Sym0KindInference :: SameKind (Apply MkD3Sym0 arg) (MkD3Sym1 arg) =>                                  MkD3Sym0 a0123456789876543210-    type instance Apply MkD3Sym0 a0123456789876543210 = MkD3Sym1 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@@ -150,68 +150,77 @@       where         MkD3Sym1KindInference :: SameKind (Apply (MkD3Sym1 a0123456789876543210) arg) (MkD3Sym2 a0123456789876543210 arg) =>                                  MkD3Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (MkD3Sym1 a0123456789876543210) a0123456789876543210 = MkD3 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. (~>) a (D4 @a)+    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 MkD4Sym0 a0123456789876543210 = MkD4 a0123456789876543210+    type instance Apply @a @(D4 @a) MkD4Sym0 a0123456789876543210 = MkD4 a0123456789876543210     instance SuppressUnusedWarnings MkD4Sym0 where       suppressUnusedWarnings = snd ((,) MkD4Sym0KindInference ())-    type MkD4Sym1 :: forall a. a -> D4 @a-    type family MkD4Sym1 @a (a0123456789876543210 :: a) :: D4 @a where+    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 a b. (~>) (Proxy a) (Proxy b)+    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 Meth1Sym0 a0123456789876543210 = Meth1 a0123456789876543210+    type instance Apply @(Proxy a) @(Proxy b) Meth1Sym0 a0123456789876543210 = Meth1 a0123456789876543210     instance SuppressUnusedWarnings Meth1Sym0 where       suppressUnusedWarnings = snd ((,) Meth1Sym0KindInference ())-    type Meth1Sym1 :: forall a b. Proxy a -> Proxy b-    type family Meth1Sym1 @a @b (a0123456789876543210 :: Proxy a) :: Proxy b where+    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 a b. (~>) (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 Meth2Sym0 a0123456789876543210 = Meth2 a0123456789876543210+    type instance Apply @(Proxy a) @(Proxy b) Meth2Sym0 a0123456789876543210 = Meth2 a0123456789876543210     instance SuppressUnusedWarnings Meth2Sym0 where       suppressUnusedWarnings = snd ((,) Meth2Sym0KindInference ())-    type Meth2Sym1 :: forall a b. Proxy a -> Proxy b-    type family Meth2Sym1 @a @b (a0123456789876543210 :: Proxy a) :: Proxy b where+    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 a b. (~>) (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 Meth3Sym0 a0123456789876543210 = Meth3 a0123456789876543210+    type instance Apply @(Proxy a) @(Proxy b) Meth3Sym0 a0123456789876543210 = Meth3 a0123456789876543210     instance SuppressUnusedWarnings Meth3Sym0 where       suppressUnusedWarnings = snd ((,) Meth3Sym0KindInference ())-    type Meth3Sym1 :: forall a b. Proxy a -> Proxy b-    type family Meth3Sym1 @a @b (a0123456789876543210 :: Proxy a) :: Proxy b where+    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. a-    type family Meth4Sym0 @a :: a where+    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@@ -251,22 +260,24 @@     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 (n :: a). (Sing n) -> SD4 (MkD4 n :: D4 @a)+      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 (Apply Meth1Sym0 t :: Proxy b) :: Type)+         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 (Apply Meth2Sym0 t :: Proxy b) :: Type)+         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 (Apply Meth3Sym0 t :: Proxy b) :: Type)+         Sing t -> Sing (Meth3 t :: Proxy b) :: Type)     class SC4 @a where-      sMeth4 :: (Sing (Meth4Sym0 :: a) :: Type)+      sMeth4 :: (Sing (Meth4 :: a) :: Type)     instance (SingI n, SingI n) =>              SingI (MkD1 (n :: Proxy a) (n :: Proxy b)) where       sing = SMkD1 sing sing
tests/compile-and-dump/Singletons/Undef.golden view
@@ -14,7 +14,7 @@       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 ())     type BarSym1 :: Bool -> Bool@@ -25,7 +25,7 @@       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 ())     type FooSym1 :: Bool -> Bool@@ -38,15 +38,15 @@     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) :: Type)+      (forall (t :: Bool). Sing t -> Sing (Bar t :: Bool) :: Type)     sFoo ::-      (forall (t :: Bool).-       Sing t -> Sing (Apply FooSym0 t :: Bool) :: Type)+      (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     instance SingI (FooSym0 :: (~>) Bool Bool) where