diff --git a/CHANGES.md b/CHANGES.md --- a/CHANGES.md +++ b/CHANGES.md @@ -1,6 +1,90 @@ Changelog for the `singletons-base` project =========================================== +3.5.1 [2026.01.10] +------------------ +* Require building with GHC 9.14. + +3.5 [2024.12.11] +---------------- +* Require building with GHC 9.12. +* Remove the use of a custom `Setup.hs` script. This script has now been + replaced with a [`cabal` code + generator](https://cabal.readthedocs.io/en/stable/cabal-package-description-file.html#pkg-field-test-suite-code-generators) + As such, `singletons-base` now requires the use of `Cabal-3.8` or later in + order to build. +* The types of `sError`, `sErrorWithoutStackTrace`, and `sUndefined` are now + less polymorphic than they were before: + + ```diff + -sError :: forall a (str :: Symbol). HasCallStack => Sing str -> a + +sError :: forall a (str :: Symbol). HasCallStack => Sing str -> Sing (Error @a str) + + -sErrorWithoutStackTrace :: forall a (str :: Symbol). Sing str -> a + +sErrorWithoutStackTrace :: forall a (str :: Symbol). Sing str -> Sing (ErrorWithoutStackTrace @a str) + + -sUndefined :: forall a. HasCallStack => a + +sUndefined :: forall a. HasCallStack => Sing (Undefined @a) + ``` + + This is because the old type signatures were _too_ polymorphic, and they + required _ad hoc_ special casing in `singletons-th` in order to make them + work in generated code. The more specific type signatures that these functions + now have improve type inference and avoid the need for special casing. If you + truly need the full polymorphism of the old type signatures, use `error`, + `errorWithoutStackTrace`, or `undefined` instead. +* The kinds of `PAlternative` (and other classes in `singletons-base` that are + parameterized over a higher-kinded type variable) are less polymorphic than + they were before: + + ```diff + -type PAlternative :: (k -> Type) -> Constraint + +type PAlternative :: (Type -> Type) -> Constraint + + -type PMonadZip :: (k -> Type) -> Constraint + +type PMonadZip :: (Type -> Type) -> Constraint + + -type PMonadPlus :: (k -> Type) -> Constraint + +type PMonadPlus :: (Type -> Type) -> Constraint + ``` + + Similarly, the kinds of defunctionalization symbols for these classes (e.g., + `EmptySym0` and `(<|>@#@$)`) now use `Type -> Type` instead of `k -> Type`. + The fact that these were kind-polymorphic to begin with was an oversight, as + these could not be used when `k` was instantiated to any other kind besides + `Type`. +* The kinds in the `PFunctor` instance for `Compose` are less polymorphic than + they were before: + + ```diff + -instance PFunctor (Compose (f :: k -> Type) (g :: Type -> k)) + +instance PFunctor (Compose (f :: Type -> Type) (g :: Type -> Type)) + ``` + + Similarly for the `PFoldable`, `PTraversable`, `PApplicative`, and + `PAlternative` instances for `Compose`. The fact that these instances were so + polymorphic to begin with was an oversight, as these instances could not be + used when `k` was instantiated to any other kind besides `Type`. +* The kinds of `Asum` and `Msum` are less polymorphic than they were before: + + ```diff + -type Asum :: forall {j} {k} (t :: k -> Type) (f :: j -> k) (a :: j). t (f a) -> f a + +type Asum :: forall (t :: Type -> Type) (f :: Type -> Type) (a :: Type). t (f a) -> f a + + -type Msum :: forall {j} {k} (t :: k -> Type) (m :: j -> k) (a :: j). t (m a) -> m a + +type Msum :: forall (t :: Type -> Type) (m :: Type -> Type) (a :: Type). t (m a) -> m a + ``` + + Similarly, the kinds of defunctionalization symbols for these definitions + (e.g., `AsumSym0` and `MSym0`) are less polymorphic. The fact that these were + kind-polymorphic to begin with was an oversight, as these definitions could + not be used when `j` or `k` was instantiated to any other kind besides `Type`. +* Define hand-written `Sing` instances such that they explicitly match on their + types on the left-hand sides (e.g., define `type instance Sing @Symbol = + SSymbol` instead of `type instance Sing = SSymbol`. Doing so will make + `singletons-base` future-proof once + [GHC#23515](https://gitlab.haskell.org/ghc/ghc/-/issues/23515) is fixed. + 3.4 [2024.05.12] ---------------- * Require building with GHC 9.10. diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -18,7 +18,7 @@ `singletons-base` uses code that relies on bleeding-edge GHC language extensions. As such, `singletons-base` only supports the latest major version -of GHC (currently GHC 9.10). For more information, +of GHC (currently GHC 9.14). For more information, consult the `singletons` [`README`](https://github.com/goldfirere/singletons/blob/master/README.md). diff --git a/Setup.hs b/Setup.hs --- a/Setup.hs +++ b/Setup.hs @@ -1,138 +1,7 @@ {-# OPTIONS_GHC -Wall #-} -module Main (main) where - -import Control.Monad - -import qualified Data.List as List -import Data.String +module Main where -import Distribution.PackageDescription import Distribution.Simple -import Distribution.Simple.BuildPaths -import Distribution.Simple.LocalBuildInfo -import Distribution.Simple.PackageIndex -import Distribution.Simple.Program -import Distribution.Simple.Setup -import Distribution.Simple.Utils -import Distribution.Text -import System.Directory -import System.FilePath - main :: IO () -main = defaultMainWithHooks simpleUserHooks - { buildHook = \pkg lbi hooks flags -> do - generateBuildModule flags pkg lbi - buildHook simpleUserHooks pkg lbi hooks flags - , confHook = \(gpd, hbi) flags -> - confHook simpleUserHooks (amendGPD gpd, hbi) flags - , haddockHook = \pkg lbi hooks flags -> do - generateBuildModule (haddockToBuildFlags flags) pkg lbi - haddockHook simpleUserHooks pkg lbi hooks flags - } - --- | Convert only flags used by 'generateBuildModule'. -haddockToBuildFlags :: HaddockFlags -> BuildFlags -haddockToBuildFlags f = emptyBuildFlags - { buildVerbosity = haddockVerbosity f - , buildDistPref = haddockDistPref f - } - -generateBuildModule :: BuildFlags -> PackageDescription -> LocalBuildInfo -> IO () -generateBuildModule flags pkg lbi = do - rootDir <- getCurrentDirectory - let verbosity = fromFlag (buildVerbosity flags) - distPref = fromFlag (buildDistPref flags) - distPref' | isRelative distPref = rootDir distPref - | otherwise = distPref - -- Package DBs - dbStack = withPackageDB lbi ++ [ SpecificPackageDB $ distPref' "package.conf.inplace" ] - dbFlags = "-hide-all-packages" : "-package-env=-" : packageDbArgsDb dbStack - - ghc = case lookupProgram ghcProgram (withPrograms lbi) of - Just fp -> locationPath $ programLocation fp - Nothing -> error "Can't find GHC path" - withTestLBI pkg lbi $ \suite suitecfg -> when (testName suite == fromString testSuiteName) $ do - let testAutogenDir = autogenComponentModulesDir lbi suitecfg - createDirectoryIfMissingVerbose verbosity True testAutogenDir - let buildSingletonsBaseFile = testAutogenDir buildSingletonsBaseModule <.> "hs" - withLibLBI pkg lbi $ \_ libCLBI -> do - let libDeps = map fst $ componentPackageDeps libCLBI - pidx = case dependencyClosure (installedPkgs lbi) libDeps of - Left p -> p - Right _ -> error "Broken dependency closure" - libTransDeps = map installedUnitId $ allPackages pidx - singletonsBaseUnitId = componentUnitId libCLBI - deps = formatDeps (singletonsBaseUnitId:libTransDeps) - allFlags = dbFlags ++ deps - writeFile buildSingletonsBaseFile $ unlines - [ "module Build_singletons_base where" - , "" - , "ghcPath :: FilePath" - , "ghcPath = " ++ show ghc - , "" - , "ghcFlags :: [String]" - , "ghcFlags = " ++ show allFlags - , "" - , "rootDir :: FilePath" - , "rootDir = " ++ show rootDir - ] - where - formatDeps = map formatOne - formatOne installedPkgId = "-package-id=" ++ display installedPkgId - - -- GHC >= 7.6 uses the '-package-db' flag. See - -- https://ghc.haskell.org/trac/ghc/ticket/5977. - packageDbArgsDb :: [PackageDB] -> [String] - -- special cases to make arguments prettier in common scenarios - packageDbArgsDb dbstack = case dbstack of - (GlobalPackageDB:UserPackageDB:dbs) - | all isSpecific dbs -> concatMap single dbs - (GlobalPackageDB:dbs) - | all isSpecific dbs -> "-no-user-package-db" - : concatMap single dbs - dbs -> "-clear-package-db" - : concatMap single dbs - where - single (SpecificPackageDB db) = [ "-package-db=" ++ db ] - single GlobalPackageDB = [ "-global-package-db" ] - single UserPackageDB = [ "-user-package-db" ] - isSpecific (SpecificPackageDB _) = True - isSpecific _ = False - -buildSingletonsBaseModule :: FilePath -buildSingletonsBaseModule = "Build_singletons_base" - -testSuiteName :: String -testSuiteName = "singletons-base-test-suite" - -amendGPD :: GenericPackageDescription -> GenericPackageDescription -amendGPD gpd = gpd - { condTestSuites = map f (condTestSuites gpd) - } - where - f (name, condTree) - | name == fromString testSuiteName = (name, condTree') - | otherwise = (name, condTree) - where - -- I miss 'lens' - testSuite = condTreeData condTree - bi = testBuildInfo testSuite - om = otherModules bi - am = autogenModules bi - - -- Cons the module to both other-modules and autogen-modules. - -- At the moment, cabal-spec-2.0 and cabal-spec-2.2 don't have - -- "all autogen-modules are other-modules if they aren't exposed-modules" - -- rule. Hopefully cabal-spec-3.0 will have. - -- - -- Note: we `nub`, because it's unclear if that's ok to have duplicate - -- modules in the lists. - om' = List.nub $ mn : om - am' = List.nub $ mn : am - - mn = fromString buildSingletonsBaseModule - - bi' = bi { otherModules = om', autogenModules = am' } - testSuite' = testSuite { testBuildInfo = bi' } - condTree' = condTree { condTreeData = testSuite' } +main = defaultMain diff --git a/singletons-base.cabal b/singletons-base.cabal --- a/singletons-base.cabal +++ b/singletons-base.cabal @@ -1,6 +1,6 @@ +cabal-version: 3.8 name: singletons-base -version: 3.4 -cabal-version: 1.24 +version: 3.5.1 synopsis: A promoted and singled version of the base library homepage: http://www.github.com/goldfirere/singletons category: Dependent Types @@ -8,19 +8,21 @@ maintainer: Ryan Scott 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.14.1 +extra-doc-files: CHANGES.md +extra-source-files: README.md + tests/README.md + tests/compile-and-dump/GradingClient/*.hs + tests/compile-and-dump/InsertionSort/*.hs + tests/compile-and-dump/Promote/*.hs tests/compile-and-dump/Singletons/*.hs - tests/compile-and-dump/GradingClient/*.golden, - tests/compile-and-dump/InsertionSort/*.golden, - tests/compile-and-dump/Promote/*.golden, + tests/compile-and-dump/GradingClient/*.golden + tests/compile-and-dump/InsertionSort/*.golden + tests/compile-and-dump/Promote/*.golden tests/compile-and-dump/Singletons/*.golden -license: BSD3 +license: BSD-3-Clause license-file: LICENSE -build-type: Custom +build-type: Simple description: @singletons-base@ uses @singletons-th@ to define promoted and singled functions from the @base@ library, including the "Prelude". This library was @@ -38,7 +40,7 @@ . @singletons-base@ uses code that relies on bleeding-edge GHC language extensions. As such, @singletons-base@ only supports the latest major version - of GHC (currently GHC 9.10). For more information, + of GHC (currently GHC 9.14). For more information, consult the @singletons@ @@. . @@ -63,23 +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.22 && < 4.23, pretty, singletons == 3.0.*, - singletons-th >= 3.4 && < 3.5, - template-haskell >= 2.22 && < 2.23, - text >= 1.2, - th-desugar >= 1.17 && < 1.18 - default-language: GHC2021 + singletons-th >= 3.5.1 && < 3.6, + template-haskell >= 2.24 && < 2.25, + text >= 1.2 + default-language: GHC2024 other-extensions: TemplateHaskell exposed-modules: Data.Singletons.Base.CustomStar Data.Singletons.Base.Enum @@ -151,17 +145,29 @@ type: exitcode-stdio-1.0 hs-source-dirs: tests ghc-options: -Wall -Wcompat -threaded -with-rtsopts=-maxN16 - default-language: GHC2021 + default-language: GHC2024 main-is: SingletonsBaseTestSuite.hs other-modules: SingletonsBaseTestSuiteUtils - build-depends: base >= 4.20 && < 4.21, + build-depends: base >= 4.22 && < 4.23, bytestring >= 0.10.9, deepseq >= 1.4.4, filepath >= 1.3, + ghc-paths >= 0.1, process >= 1.1, turtle >= 1.5, text >= 1.2, singletons-base, tasty >= 1.2, - tasty-golden >= 2.2 + tasty-golden >= 2.2, + + -- Dependencies only used when invoking GHC in the test + -- suite + ghc-prim, + ghc-internal, + mtl, + template-haskell, + th-desugar, + transformers + build-tool-depends: singletons-base-code-generator:singletons-base-code-generator + code-generators: singletons-base-code-generator diff --git a/src/Control/Applicative/Singletons.hs b/src/Control/Applicative/Singletons.hs --- a/src/Control/Applicative/Singletons.hs +++ b/src/Control/Applicative/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Control/Monad/Fail/Singletons.hs b/src/Control/Monad/Fail/Singletons.hs --- a/src/Control/Monad/Fail/Singletons.hs +++ b/src/Control/Monad/Fail/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} @@ -25,6 +24,7 @@ ) where import Control.Monad.Singletons.Internal +import Data.Kind import Data.Singletons.Base.Instances import Data.Singletons.TH @@ -49,6 +49,10 @@ -- @ -- fail _ = mzero -- @ + + -- See Note [Using standalone kind signatures not present in the base library] + -- in Control.Monad.Singletons.Internal. + type MonadFail :: (Type -> Type) -> Constraint class Monad m => MonadFail m where fail :: String -> m a diff --git a/src/Control/Monad/Singletons.hs b/src/Control/Monad/Singletons.hs --- a/src/Control/Monad/Singletons.hs +++ b/src/Control/Monad/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Control/Monad/Singletons/Internal.hs b/src/Control/Monad/Singletons/Internal.hs --- a/src/Control/Monad/Singletons/Internal.hs +++ b/src/Control/Monad/Singletons/Internal.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-} @@ -33,6 +32,7 @@ import Control.Applicative import Control.Monad +import Data.Kind import Data.List.NonEmpty (NonEmpty(..)) import Data.Singletons.Base.Instances import Data.Singletons.TH @@ -51,6 +51,8 @@ satisfy these laws. -} + -- See Note [Using standalone kind signatures not present in the base library] + type Functor :: (Type -> Type) -> Constraint class Functor f where fmap :: (a -> b) -> f a -> f b @@ -126,6 +128,8 @@ -- -- (which implies that 'pure' and '<*>' satisfy the applicative functor laws). + -- See Note [Using standalone kind signatures not present in the base library] + type Applicative :: (Type -> Type) -> Constraint class Functor f => Applicative f where -- {-# MINIMAL pure, ((<*>) | liftA2) #-} -- -| Lift a value. @@ -243,6 +247,9 @@ The instances of 'Monad' for lists, 'Data.Maybe.Maybe' and 'System.IO.IO' defined in the "Prelude" satisfy these laws. -} + + -- See Note [Using standalone kind signatures not present in the base library] + type Monad :: (Type -> Type) -> Constraint class Applicative m => Monad m where -- -| Sequentially compose two actions, passing any value produced -- by the first as an argument to the second. @@ -352,6 +359,9 @@ -- -* @'some' v = (:) '<$>' v '<*>' 'many' v@ -- -- -* @'many' v = 'some' v '<|>' 'pure' []@ + + -- See Note [Using standalone kind signatures not present in the base library] + type Alternative :: (Type -> Type) -> Constraint class Applicative f => Alternative f where -- -| The identity of '<|>' empty :: f a @@ -386,6 +396,9 @@ -- The MonadPlus class definition -- -| Monads that also support choice and failure. + + -- See Note [Using standalone kind signatures not present in the base library] + type MonadPlus :: (Type -> Type) -> Constraint class (Alternative m, Monad m) => MonadPlus m where -- -| The identity of 'mplus'. It should also satisfy the equations -- @@ -479,3 +492,18 @@ instance MonadPlus Maybe instance MonadPlus [] |]) + +{- +Note [Using standalone kind signatures not present in the base library] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Various type class definitions in singletons-base (Functor, Foldable, +Alternative, etc.) are defined using standalone kind signatures. These +standalone kind signatures are /not/ present in the original `base` library, +however: these are specifically required by singletons-th. More precisely, all +of these classes are parameterized by a type variable of kind `Type -> Type`, +and we want to ensure that the promoted class (and the defunctionalization +symbols for its class methods) all use `Type -> Type` in their kinds as well. +For more details on why singletons-th requires this, see Note [Propagating kind +information from class standalone kind signatures] in D.S.TH.Promote in +singletons-th. +-} diff --git a/src/Control/Monad/Zip/Singletons.hs b/src/Control/Monad/Zip/Singletons.hs --- a/src/Control/Monad/Zip/Singletons.hs +++ b/src/Control/Monad/Zip/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} @@ -30,6 +29,7 @@ import Control.Monad.Singletons.Internal import Data.Functor.Identity import Data.Functor.Identity.Singletons +import Data.Kind import Data.List.Singletons ( ZipSym0, ZipWithSym0, UnzipSym0 , sZip, sZipWith, sUnzip ) @@ -56,6 +56,10 @@ -- > ==> -- > munzip (mzip ma mb) = (ma, mb) -- + + -- See Note [Using standalone kind signatures not present in the base library] + -- in Control.Monad.Singletons.Internal. + type MonadZip :: (Type -> Type) -> Constraint class Monad m => MonadZip m where -- {-# MINIMAL mzip | mzipWith #-} diff --git a/src/Data/Bool/Singletons.hs b/src/Data/Bool/Singletons.hs --- a/src/Data/Bool/Singletons.hs +++ b/src/Data/Bool/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} diff --git a/src/Data/Either/Singletons.hs b/src/Data/Either/Singletons.hs --- a/src/Data/Either/Singletons.hs +++ b/src/Data/Either/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Data/Eq/Singletons.hs b/src/Data/Eq/Singletons.hs --- a/src/Data/Eq/Singletons.hs +++ b/src/Data/Eq/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} diff --git a/src/Data/Foldable/Singletons.hs b/src/Data/Foldable/Singletons.hs --- a/src/Data/Foldable/Singletons.hs +++ b/src/Data/Foldable/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-} @@ -127,7 +126,7 @@ type SEndo :: Endo a -> Type data SEndo e where SEndo :: Sing x -> SEndo ('Endo x) -type instance Sing = SEndo +type instance Sing @(Endo a) = SEndo type EndoSym0 :: (a ~> a) ~> Endo a data EndoSym0 tf type instance Apply EndoSym0 x = 'Endo x @@ -215,6 +214,9 @@ -- -- > foldMap f . fmap g = foldMap (f . g) + -- See Note [Using standalone kind signatures not present in the base library] + -- in Control.Monad.Singletons.Internal. + type Foldable :: (Type -> Type) -> Constraint class Foldable t where -- {-# MINIMAL foldMap | foldr #-} @@ -578,16 +580,37 @@ sequence_ :: (Foldable t, Monad m) => t (m a) -> m () sequence_ = foldr (>>) (return ()) + -- Note that in the type signatures for `asum` and `msum` below, we explicitly + -- annotate `f` and `m` with the kind (Type -> Type), which is not something + -- that is done in the original base library. This is because when + -- singletons-th promotes type signatures, it omits constraints such as + -- `Alternative f` and `MonadPlus m`, which are essential for inferring that + -- `f` and `m` are of kind `Type -> Type`. Without these constraints, we may + -- end up with a promoted definition that looks like this: + -- + -- type Asum :: t (f a) -> f a + -- + -- This will result in Asum having a more polymorphic kind than intended, + -- since GHC will generalize Asum's kind to: + -- + -- type Asum :: forall {j} {k} (t :: k -> Type) (f :: j -> k) (a :: j). t (f a) -> f a + -- + -- Annotating `f :: Type -> Type` (and similarly for `m`) is a clunky but + -- reliable way of preventing this. See also Note [Using standalone kind + -- signatures not present in the base library] in + -- Control.Monad.Singletons.Internal for a similar situation where class + -- definitions can become overly polymorphic unless given an explicit kind. + -- -| The sum of a collection of actions, generalizing 'concat'. -- -- asum [Just "Hello", Nothing, Just "World"] -- Just "Hello" - asum :: (Foldable t, Alternative f) => t (f a) -> f a + asum :: forall t (f :: Type -> Type) a. (Foldable t, Alternative f) => t (f a) -> f a asum = foldr (<|>) empty -- -| The sum of a collection of actions, generalizing 'concat'. -- As of base 4.8.0.0, 'msum' is just 'asum', specialized to 'MonadPlus'. - msum :: (Foldable t, MonadPlus m) => t (m a) -> m a + msum :: forall t (m :: Type -> Type) a. (Foldable t, MonadPlus m) => t (m a) -> m a msum = asum -- -| The concatenation of all the elements of a container of lists. diff --git a/src/Data/Function/Singletons.hs b/src/Data/Function/Singletons.hs --- a/src/Data/Function/Singletons.hs +++ b/src/Data/Function/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Data/Functor/Compose/Singletons.hs b/src/Data/Functor/Compose/Singletons.hs --- a/src/Data/Functor/Compose/Singletons.hs +++ b/src/Data/Functor/Compose/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} @@ -36,65 +35,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) |]) diff --git a/src/Data/Functor/Const/Singletons.hs b/src/Data/Functor/Const/Singletons.hs --- a/src/Data/Functor/Const/Singletons.hs +++ b/src/Data/Functor/Const/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} @@ -32,73 +31,28 @@ import Control.Monad.Singletons.Internal import Data.Eq.Singletons import Data.Foldable.Singletons -import Data.Kind (Type) import Data.Monoid.Singletons import Data.Ord.Singletons import Data.Semigroup.Singletons.Internal.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) diff --git a/src/Data/Functor/Identity/Singletons.hs b/src/Data/Functor/Identity/Singletons.hs --- a/src/Data/Functor/Identity/Singletons.hs +++ b/src/Data/Functor/Identity/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} diff --git a/src/Data/Functor/Product/Singletons.hs b/src/Data/Functor/Product/Singletons.hs --- a/src/Data/Functor/Product/Singletons.hs +++ b/src/Data/Functor/Product/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} @@ -42,46 +41,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 +67,44 @@ Pair f g <*> Pair x y = Pair (f <*> x) (g <*> y) liftA2 f (Pair a b) (Pair x y) = Pair (liftA2 f a x) (liftA2 f b y) - instance (Alternative f, Alternative g) => Alternative (Product f g) where - empty = Pair empty empty - Pair x1 y1 <|> Pair x2 y2 = Pair (x1 <|> x2) (y1 <|> y2) - instance (Monad f, Monad g) => Monad (Product f g) where Pair m n >>= f = Pair (m >>= fstP . f) (n >>= sndP . f) where fstP (Pair a _) = a sndP (Pair _ b) = b - instance (MonadPlus f, MonadPlus g) => MonadPlus (Product f g) where - mzero = Pair mzero mzero - Pair x1 y1 `mplus` Pair x2 y2 = Pair (x1 `mplus` x2) (y1 `mplus` y2) - instance (MonadZip f, MonadZip g) => MonadZip (Product f g) where mzipWith f (Pair x1 y1) (Pair x2 y2) = Pair (mzipWith f x1 x2) (mzipWith f y1 y2) + + -- Note that in the instances below, we explicitly annotate `f` with its kind + -- (Type -> Type), which is not something that is done in the original base + -- library. This is because when singletons-th promotes instance declarations, + -- it omits the instance contexts when generating the helper type families. + -- This can lead to the helper type families having overly polymorphic kinds. + -- For example, if the Alternative instance below lacked the explicit + -- (f :: Type -> Type) kind signature, the generated code would look like: + -- + -- instance PAlternative (Product f g) where + -- type Empty = EmptyHelper + -- ... + -- + -- type EmptyHelper :: forall f g a. Product f g a + -- + -- This will result in EmptyHelper having a more polymorphic kind than + -- intended, since GHC will generalize EmptyHelper's kind to: + -- + -- type EmptyHelper :: forall {k} (f :: k -> Type) (g :: k -> Type) (a :: k). Product f g a + -- + -- Annotating `f :: Type -> Type` is a clunky but reliable way of preventing + -- this. See also Note [Using standalone kind signatures not present in the + -- base library] in Control.Monad.Singletons.Internal for a similar situation + -- where class definitions can become overly polymorphic unless given an + -- explicit kind. + instance (Alternative f, Alternative g) => Alternative (Product (f :: Type -> Type) g) where + empty = Pair empty empty + Pair x1 y1 <|> Pair x2 y2 = Pair (x1 <|> x2) (y1 <|> y2) + + instance (MonadPlus f, MonadPlus g) => MonadPlus (Product (f :: Type -> Type) g) where + mzero = Pair mzero mzero + Pair x1 y1 `mplus` Pair x2 y2 = Pair (x1 `mplus` x2) (y1 `mplus` y2) |]) diff --git a/src/Data/Functor/Singletons.hs b/src/Data/Functor/Singletons.hs --- a/src/Data/Functor/Singletons.hs +++ b/src/Data/Functor/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} diff --git a/src/Data/Functor/Sum/Singletons.hs b/src/Data/Functor/Sum/Singletons.hs --- a/src/Data/Functor/Sum/Singletons.hs +++ b/src/Data/Functor/Sum/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} @@ -32,56 +31,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) diff --git a/src/Data/List/NonEmpty/Singletons.hs b/src/Data/List/NonEmpty/Singletons.hs --- a/src/Data/List/NonEmpty/Singletons.hs +++ b/src/Data/List/NonEmpty/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Data/List/Singletons.hs b/src/Data/List/Singletons.hs --- a/src/Data/List/Singletons.hs +++ b/src/Data/List/Singletons.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE ExplicitNamespaces #-} - ----------------------------------------------------------------------------- -- | -- Module : Data.List.Singletons diff --git a/src/Data/List/Singletons/Internal.hs b/src/Data/List/Singletons/Internal.hs --- a/src/Data/List/Singletons/Internal.hs +++ b/src/Data/List/Singletons/Internal.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} diff --git a/src/Data/List/Singletons/Internal/Disambiguation.hs b/src/Data/List/Singletons/Internal/Disambiguation.hs --- a/src/Data/List/Singletons/Internal/Disambiguation.hs +++ b/src/Data/List/Singletons/Internal/Disambiguation.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Data/Maybe/Singletons.hs b/src/Data/Maybe/Singletons.hs --- a/src/Data/Maybe/Singletons.hs +++ b/src/Data/Maybe/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Data/Monoid/Singletons.hs b/src/Data/Monoid/Singletons.hs --- a/src/Data/Monoid/Singletons.hs +++ b/src/Data/Monoid/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-} diff --git a/src/Data/Ord/Singletons.hs b/src/Data/Ord/Singletons.hs --- a/src/Data/Ord/Singletons.hs +++ b/src/Data/Ord/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} diff --git a/src/Data/Ord/Singletons/Disambiguation.hs b/src/Data/Ord/Singletons/Disambiguation.hs --- a/src/Data/Ord/Singletons/Disambiguation.hs +++ b/src/Data/Ord/Singletons/Disambiguation.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Data/Proxy/Singletons.hs b/src/Data/Proxy/Singletons.hs --- a/src/Data/Proxy/Singletons.hs +++ b/src/Data/Proxy/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} @@ -32,17 +31,16 @@ import Control.Monad import Control.Monad.Singletons.Internal import Data.Eq.Singletons -import Data.Kind import Data.Monoid.Singletons import Data.Ord.Singletons import Data.Proxy import Data.Semigroup (Semigroup(..)) import Data.Semigroup.Singletons.Internal.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 +48,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 diff --git a/src/Data/Semigroup/Singletons.hs b/src/Data/Semigroup/Singletons.hs --- a/src/Data/Semigroup/Singletons.hs +++ b/src/Data/Semigroup/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} diff --git a/src/Data/Semigroup/Singletons/Internal/Classes.hs b/src/Data/Semigroup/Singletons/Internal/Classes.hs --- a/src/Data/Semigroup/Singletons/Internal/Classes.hs +++ b/src/Data/Semigroup/Singletons/Internal/Classes.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} diff --git a/src/Data/Semigroup/Singletons/Internal/Disambiguation.hs b/src/Data/Semigroup/Singletons/Internal/Disambiguation.hs --- a/src/Data/Semigroup/Singletons/Internal/Disambiguation.hs +++ b/src/Data/Semigroup/Singletons/Internal/Disambiguation.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Data/Semigroup/Singletons/Internal/Wrappers.hs b/src/Data/Semigroup/Singletons/Internal/Wrappers.hs --- a/src/Data/Semigroup/Singletons/Internal/Wrappers.hs +++ b/src/Data/Semigroup/Singletons/Internal/Wrappers.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} diff --git a/src/Data/Singletons/Base/Enum.hs b/src/Data/Singletons/Base/Enum.hs --- a/src/Data/Singletons/Base/Enum.hs +++ b/src/Data/Singletons/Base/Enum.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} diff --git a/src/Data/Singletons/Base/Instances.hs b/src/Data/Singletons/Base/Instances.hs --- a/src/Data/Singletons/Base/Instances.hs +++ b/src/Data/Singletons/Base/Instances.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Data/Singletons/Base/PolyError.hs b/src/Data/Singletons/Base/PolyError.hs --- a/src/Data/Singletons/Base/PolyError.hs +++ b/src/Data/Singletons/Base/PolyError.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Data/Singletons/Base/SomeSing.hs b/src/Data/Singletons/Base/SomeSing.hs --- a/src/Data/Singletons/Base/SomeSing.hs +++ b/src/Data/Singletons/Base/SomeSing.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE DataKinds #-} -{-# LANGUAGE GADTs #-} {-# OPTIONS_GHC -Wno-orphans #-} ----------------------------------------------------------------------------- diff --git a/src/Data/Singletons/Base/TH.hs b/src/Data/Singletons/Base/TH.hs --- a/src/Data/Singletons/Base/TH.hs +++ b/src/Data/Singletons/Base/TH.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE ExplicitNamespaces #-} - ----------------------------------------------------------------------------- -- | -- Module : Data.Singletons.Base.TH diff --git a/src/Data/Singletons/Base/TypeError.hs b/src/Data/Singletons/Base/TypeError.hs --- a/src/Data/Singletons/Base/TypeError.hs +++ b/src/Data/Singletons/Base/TypeError.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} @@ -82,7 +81,7 @@ infixl 6 :%<>: infixl 5 :%$$: -type instance Sing = SErrorMessage +type instance Sing @PErrorMessage = SErrorMessage instance SingKind PErrorMessage where type Demote PErrorMessage = ErrorMessage diff --git a/src/Data/String/Singletons.hs b/src/Data/String/Singletons.hs --- a/src/Data/String/Singletons.hs +++ b/src/Data/String/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Data/Traversable/Singletons.hs b/src/Data/Traversable/Singletons.hs --- a/src/Data/Traversable/Singletons.hs +++ b/src/Data/Traversable/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE NoNamedWildCards #-} {-# LANGUAGE TemplateHaskell #-} @@ -64,7 +63,7 @@ type SStateL :: forall s a. StateL s a -> Type data SStateL state where SStateL :: Sing x -> SStateL ('StateL x) -type instance Sing = SStateL +type instance Sing @(StateL s a) = SStateL type StateLSym0 :: forall s a. (s ~> (s, a)) ~> StateL s a data StateLSym0 z type instance Apply StateLSym0 x = 'StateL x @@ -74,7 +73,7 @@ type SStateR :: forall s a. StateR s a -> Type data SStateR state where SStateR :: Sing x -> SStateR ('StateR x) -type instance Sing = SStateR +type instance Sing @(StateR s a) = SStateR type StateRSym0 :: forall s a. (s ~> (s, a)) ~> StateR s a data StateRSym0 z type instance Apply StateRSym0 x = 'StateR x @@ -171,6 +170,10 @@ -- equivalent to traversal with a constant applicative functor -- ('foldMapDefault'). -- + + -- See Note [Using standalone kind signatures not present in the base library] + -- in Control.Monad.Singletons.Internal. + type Traversable :: (Type -> Type) -> Constraint class (Functor t, Foldable t) => Traversable t where -- {-# MINIMAL traverse | sequenceA #-} diff --git a/src/Data/Tuple/Singletons.hs b/src/Data/Tuple/Singletons.hs --- a/src/Data/Tuple/Singletons.hs +++ b/src/Data/Tuple/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/Data/Void/Singletons.hs b/src/Data/Void/Singletons.hs --- a/src/Data/Void/Singletons.hs +++ b/src/Data/Void/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/GHC/Base/Singletons.hs b/src/GHC/Base/Singletons.hs --- a/src/GHC/Base/Singletons.hs +++ b/src/GHC/Base/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} {-# LANGUAGE TypeFamilies #-} diff --git a/src/GHC/Num/Singletons.hs b/src/GHC/Num/Singletons.hs --- a/src/GHC/Num/Singletons.hs +++ b/src/GHC/Num/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE NoStarIsType #-} {-# LANGUAGE TemplateHaskell #-} diff --git a/src/GHC/TypeLits/Singletons.hs b/src/GHC/TypeLits/Singletons.hs --- a/src/GHC/TypeLits/Singletons.hs +++ b/src/GHC/TypeLits/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeFamilies #-} @@ -22,9 +21,9 @@ module GHC.TypeLits.Singletons ( Natural, Symbol, Char, Sing, - SNat, pattern SNat, - SSymbol, pattern SSymbol, pattern SSym, - SChar, pattern SChar, + SNat, data SNat, + SSymbol, data SSymbol, data SSym, + SChar, data SChar, withKnownNat, withKnownSymbol, withKnownChar, Error, sError, ErrorWithoutStackTrace, sErrorWithoutStackTrace, diff --git a/src/GHC/TypeLits/Singletons/Internal.hs b/src/GHC/TypeLits/Singletons/Internal.hs --- a/src/GHC/TypeLits/Singletons/Internal.hs +++ b/src/GHC/TypeLits/Singletons/Internal.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} @@ -25,9 +24,9 @@ Sing, Natural, TL.Symbol, Char, - TN.SNat, pattern TN.SNat, - TL.SSymbol, pattern TL.SSymbol, pattern SSym, - TL.SChar, pattern TL.SChar, + TN.SNat, data TN.SNat, + TL.SSymbol, data TL.SSymbol, data SSym, + TL.SChar, data TL.SChar, TN.withKnownNat, TL.withKnownSymbol, TL.withKnownChar, Error, sError, ErrorWithoutStackTrace, sErrorWithoutStackTrace, @@ -66,7 +65,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 +76,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 +92,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 +217,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 +228,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 +237,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. diff --git a/src/Prelude/Singletons.hs b/src/Prelude/Singletons.hs --- a/src/Prelude/Singletons.hs +++ b/src/Prelude/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE ExplicitNamespaces #-} {-# LANGUAGE NoStarIsType #-} ----------------------------------------------------------------------------- diff --git a/src/Text/Show/Singletons.hs b/src/Text/Show/Singletons.hs --- a/src/Text/Show/Singletons.hs +++ b/src/Text/Show/Singletons.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} diff --git a/tests/SingletonsBaseTestSuite.hs b/tests/SingletonsBaseTestSuite.hs --- a/tests/SingletonsBaseTestSuite.hs +++ b/tests/SingletonsBaseTestSuite.hs @@ -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 diff --git a/tests/SingletonsBaseTestSuiteUtils.hs b/tests/SingletonsBaseTestSuiteUtils.hs --- a/tests/SingletonsBaseTestSuiteUtils.hs +++ b/tests/SingletonsBaseTestSuiteUtils.hs @@ -1,5 +1,4 @@ {-# LANGUAGE DeriveAnyClass #-} -{-# LANGUAGE DerivingStrategies #-} {-# LANGUAGE OverloadedStrings #-} module SingletonsBaseTestSuiteUtils ( @@ -10,13 +9,12 @@ , cleanFiles ) where -import Build_singletons_base ( ghcPath, ghcFlags, rootDir ) import Control.Exception ( Exception ) import Data.Foldable ( asum ) import Data.Text ( Text ) import Data.String ( IsString(fromString) ) -import System.FilePath ( takeBaseName, pathSeparator ) -import System.FilePath ( () ) +import GHC.Paths ( ghc ) +import System.FilePath ( (), takeBaseName, pathSeparator ) import System.IO ( IOMode(..), openFile ) import System.Process ( CreateProcess(..), StdStream(..) , createProcess, proc, waitForProcess @@ -26,6 +24,8 @@ import qualified Data.Text as Text import qualified Turtle +import SingletonsBaseGHCFlags ( ghcFlags, rootDir ) + -- Some infractructure for handling external process errors newtype ProcessException = ProcessException String deriving newtype (Eq, Ord, Show) @@ -46,14 +46,11 @@ , "-fprint-explicit-kinds" , "-O0" , "-i" ++ goldenPath - , "-XGHC2021" + , "-XGHC2024" , "-XTemplateHaskell" - , "-XDataKinds" , "-XTypeFamilies" - , "-XGADTs" , "-XUndecidableInstances" , "-XIncoherentInstances" - , "-XLambdaCase" , "-XUnboxedTuples" , "-XDefaultSignatures" , "-XCPP" @@ -85,7 +82,7 @@ compileWithGHC :: IO () compileWithGHC = do hActualFile <- openFile actualFilePath WriteMode - (_, _, _, pid) <- createProcess (proc ghcPath (testPath : opts)) + (_, _, _, pid) <- createProcess (proc ghc (testPath : opts)) { std_out = UseHandle hActualFile , std_err = UseHandle hActualFile , cwd = Just goldenPath } diff --git a/tests/compile-and-dump/GradingClient/Database.golden b/tests/compile-and-dump/GradingClient/Database.golden --- a/tests/compile-and-dump/GradingClient/Database.golden +++ b/tests/compile-and-dump/GradingClient/Database.golden @@ -15,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.Internal.Bignum.Natural.Natural + -> U -> Symbol -> Symbol + type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: U) (a :: Symbol) :: Symbol where + ShowsPrec_0123456789876543210 _ BOOL a_0123456789876543210 = Apply (Apply ShowStringSym0 "BOOL") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ STRING a_0123456789876543210 = Apply (Apply ShowStringSym0 "STRING") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ NAT a_0123456789876543210 = Apply (Apply ShowStringSym0 "NAT") a_0123456789876543210 + ShowsPrec_0123456789876543210 p_0123456789876543210 (VEC arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "VEC ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 + instance PShow U where + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a + type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural + -> AChar -> Symbol -> Symbol + type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: AChar) (a :: Symbol) :: Symbol where + ShowsPrec_0123456789876543210 _ CA a_0123456789876543210 = Apply (Apply ShowStringSym0 "CA") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CB a_0123456789876543210 = Apply (Apply ShowStringSym0 "CB") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CC a_0123456789876543210 = Apply (Apply ShowStringSym0 "CC") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CD a_0123456789876543210 = Apply (Apply ShowStringSym0 "CD") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CE a_0123456789876543210 = Apply (Apply ShowStringSym0 "CE") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CF a_0123456789876543210 = Apply (Apply ShowStringSym0 "CF") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CG a_0123456789876543210 = Apply (Apply ShowStringSym0 "CG") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CH a_0123456789876543210 = Apply (Apply ShowStringSym0 "CH") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CI a_0123456789876543210 = Apply (Apply ShowStringSym0 "CI") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CJ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CJ") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CK a_0123456789876543210 = Apply (Apply ShowStringSym0 "CK") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CL a_0123456789876543210 = Apply (Apply ShowStringSym0 "CL") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CM a_0123456789876543210 = Apply (Apply ShowStringSym0 "CM") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CN a_0123456789876543210 = Apply (Apply ShowStringSym0 "CN") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CO a_0123456789876543210 = Apply (Apply ShowStringSym0 "CO") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CP a_0123456789876543210 = Apply (Apply ShowStringSym0 "CP") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CQ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CQ") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CR a_0123456789876543210 = Apply (Apply ShowStringSym0 "CR") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CS a_0123456789876543210 = Apply (Apply ShowStringSym0 "CS") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CT a_0123456789876543210 = Apply (Apply ShowStringSym0 "CT") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CU a_0123456789876543210 = Apply (Apply ShowStringSym0 "CU") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CV a_0123456789876543210 = Apply (Apply ShowStringSym0 "CV") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CW a_0123456789876543210 = Apply (Apply ShowStringSym0 "CW") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CX a_0123456789876543210 = Apply (Apply ShowStringSym0 "CX") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CY a_0123456789876543210 = Apply (Apply ShowStringSym0 "CY") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CZ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CZ") a_0123456789876543210 + instance PShow AChar where + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a + type TFHelper_0123456789876543210 :: AChar -> AChar -> Bool + type family TFHelper_0123456789876543210 (a :: AChar) (a :: AChar) :: Bool where + TFHelper_0123456789876543210 CA CA = TrueSym0 + TFHelper_0123456789876543210 CA CB = FalseSym0 + TFHelper_0123456789876543210 CA CC = FalseSym0 + TFHelper_0123456789876543210 CA CD = FalseSym0 + TFHelper_0123456789876543210 CA CE = FalseSym0 + TFHelper_0123456789876543210 CA CF = FalseSym0 + TFHelper_0123456789876543210 CA CG = FalseSym0 + TFHelper_0123456789876543210 CA CH = FalseSym0 + TFHelper_0123456789876543210 CA CI = FalseSym0 + TFHelper_0123456789876543210 CA CJ = FalseSym0 + TFHelper_0123456789876543210 CA CK = FalseSym0 + TFHelper_0123456789876543210 CA CL = FalseSym0 + TFHelper_0123456789876543210 CA CM = FalseSym0 + TFHelper_0123456789876543210 CA CN = FalseSym0 + TFHelper_0123456789876543210 CA CO = FalseSym0 + TFHelper_0123456789876543210 CA CP = FalseSym0 + TFHelper_0123456789876543210 CA CQ = FalseSym0 + TFHelper_0123456789876543210 CA CR = FalseSym0 + TFHelper_0123456789876543210 CA CS = FalseSym0 + TFHelper_0123456789876543210 CA CT = FalseSym0 + TFHelper_0123456789876543210 CA CU = FalseSym0 + TFHelper_0123456789876543210 CA CV = FalseSym0 + TFHelper_0123456789876543210 CA CW = FalseSym0 + TFHelper_0123456789876543210 CA CX = FalseSym0 + TFHelper_0123456789876543210 CA CY = FalseSym0 + TFHelper_0123456789876543210 CA CZ = FalseSym0 + TFHelper_0123456789876543210 CB CA = FalseSym0 + TFHelper_0123456789876543210 CB CB = TrueSym0 + TFHelper_0123456789876543210 CB CC = FalseSym0 + TFHelper_0123456789876543210 CB CD = FalseSym0 + TFHelper_0123456789876543210 CB CE = FalseSym0 + TFHelper_0123456789876543210 CB CF = FalseSym0 + TFHelper_0123456789876543210 CB CG = FalseSym0 + TFHelper_0123456789876543210 CB CH = FalseSym0 + TFHelper_0123456789876543210 CB CI = FalseSym0 + TFHelper_0123456789876543210 CB CJ = FalseSym0 + TFHelper_0123456789876543210 CB CK = FalseSym0 + TFHelper_0123456789876543210 CB CL = FalseSym0 + TFHelper_0123456789876543210 CB CM = FalseSym0 + TFHelper_0123456789876543210 CB CN = FalseSym0 + TFHelper_0123456789876543210 CB CO = FalseSym0 + TFHelper_0123456789876543210 CB CP = FalseSym0 + TFHelper_0123456789876543210 CB CQ = FalseSym0 + TFHelper_0123456789876543210 CB CR = FalseSym0 + TFHelper_0123456789876543210 CB CS = FalseSym0 + TFHelper_0123456789876543210 CB CT = FalseSym0 + TFHelper_0123456789876543210 CB CU = FalseSym0 + TFHelper_0123456789876543210 CB CV = FalseSym0 + TFHelper_0123456789876543210 CB CW = FalseSym0 + TFHelper_0123456789876543210 CB CX = FalseSym0 + TFHelper_0123456789876543210 CB CY = FalseSym0 + TFHelper_0123456789876543210 CB CZ = FalseSym0 + TFHelper_0123456789876543210 CC CA = FalseSym0 + TFHelper_0123456789876543210 CC CB = FalseSym0 + TFHelper_0123456789876543210 CC CC = TrueSym0 + TFHelper_0123456789876543210 CC CD = FalseSym0 + TFHelper_0123456789876543210 CC CE = FalseSym0 + TFHelper_0123456789876543210 CC CF = FalseSym0 + TFHelper_0123456789876543210 CC CG = FalseSym0 + TFHelper_0123456789876543210 CC CH = FalseSym0 + TFHelper_0123456789876543210 CC CI = FalseSym0 + TFHelper_0123456789876543210 CC CJ = FalseSym0 + TFHelper_0123456789876543210 CC CK = FalseSym0 + TFHelper_0123456789876543210 CC CL = FalseSym0 + TFHelper_0123456789876543210 CC CM = FalseSym0 + TFHelper_0123456789876543210 CC CN = FalseSym0 + TFHelper_0123456789876543210 CC CO = FalseSym0 + TFHelper_0123456789876543210 CC CP = FalseSym0 + TFHelper_0123456789876543210 CC CQ = FalseSym0 + TFHelper_0123456789876543210 CC CR = FalseSym0 + TFHelper_0123456789876543210 CC CS = FalseSym0 + TFHelper_0123456789876543210 CC CT = FalseSym0 + TFHelper_0123456789876543210 CC CU = FalseSym0 + TFHelper_0123456789876543210 CC CV = FalseSym0 + TFHelper_0123456789876543210 CC CW = FalseSym0 + TFHelper_0123456789876543210 CC CX = FalseSym0 + TFHelper_0123456789876543210 CC CY = FalseSym0 + TFHelper_0123456789876543210 CC CZ = FalseSym0 + TFHelper_0123456789876543210 CD CA = FalseSym0 + TFHelper_0123456789876543210 CD CB = FalseSym0 + TFHelper_0123456789876543210 CD CC = FalseSym0 + TFHelper_0123456789876543210 CD CD = TrueSym0 + TFHelper_0123456789876543210 CD CE = FalseSym0 + TFHelper_0123456789876543210 CD CF = FalseSym0 + TFHelper_0123456789876543210 CD CG = FalseSym0 + TFHelper_0123456789876543210 CD CH = FalseSym0 + TFHelper_0123456789876543210 CD CI = FalseSym0 + TFHelper_0123456789876543210 CD CJ = FalseSym0 + TFHelper_0123456789876543210 CD CK = FalseSym0 + TFHelper_0123456789876543210 CD CL = FalseSym0 + TFHelper_0123456789876543210 CD CM = FalseSym0 + TFHelper_0123456789876543210 CD CN = FalseSym0 + TFHelper_0123456789876543210 CD CO = FalseSym0 + TFHelper_0123456789876543210 CD CP = FalseSym0 + TFHelper_0123456789876543210 CD CQ = FalseSym0 + TFHelper_0123456789876543210 CD CR = FalseSym0 + TFHelper_0123456789876543210 CD CS = FalseSym0 + TFHelper_0123456789876543210 CD CT = FalseSym0 + TFHelper_0123456789876543210 CD CU = FalseSym0 + TFHelper_0123456789876543210 CD CV = FalseSym0 + TFHelper_0123456789876543210 CD CW = FalseSym0 + TFHelper_0123456789876543210 CD CX = FalseSym0 + TFHelper_0123456789876543210 CD CY = FalseSym0 + TFHelper_0123456789876543210 CD CZ = FalseSym0 + TFHelper_0123456789876543210 CE CA = FalseSym0 + TFHelper_0123456789876543210 CE CB = FalseSym0 + TFHelper_0123456789876543210 CE CC = FalseSym0 + TFHelper_0123456789876543210 CE CD = FalseSym0 + TFHelper_0123456789876543210 CE CE = TrueSym0 + TFHelper_0123456789876543210 CE CF = FalseSym0 + TFHelper_0123456789876543210 CE CG = FalseSym0 + TFHelper_0123456789876543210 CE CH = FalseSym0 + TFHelper_0123456789876543210 CE CI = FalseSym0 + TFHelper_0123456789876543210 CE CJ = FalseSym0 + TFHelper_0123456789876543210 CE CK = FalseSym0 + TFHelper_0123456789876543210 CE CL = FalseSym0 + TFHelper_0123456789876543210 CE CM = FalseSym0 + TFHelper_0123456789876543210 CE CN = FalseSym0 + TFHelper_0123456789876543210 CE CO = FalseSym0 + TFHelper_0123456789876543210 CE CP = FalseSym0 + TFHelper_0123456789876543210 CE CQ = FalseSym0 + TFHelper_0123456789876543210 CE CR = FalseSym0 + TFHelper_0123456789876543210 CE CS = FalseSym0 + TFHelper_0123456789876543210 CE CT = FalseSym0 + TFHelper_0123456789876543210 CE CU = FalseSym0 + TFHelper_0123456789876543210 CE CV = FalseSym0 + TFHelper_0123456789876543210 CE CW = FalseSym0 + TFHelper_0123456789876543210 CE CX = FalseSym0 + TFHelper_0123456789876543210 CE CY = FalseSym0 + TFHelper_0123456789876543210 CE CZ = FalseSym0 + TFHelper_0123456789876543210 CF CA = FalseSym0 + TFHelper_0123456789876543210 CF CB = FalseSym0 + TFHelper_0123456789876543210 CF CC = FalseSym0 + TFHelper_0123456789876543210 CF CD = FalseSym0 + TFHelper_0123456789876543210 CF CE = FalseSym0 + TFHelper_0123456789876543210 CF CF = TrueSym0 + TFHelper_0123456789876543210 CF CG = FalseSym0 + TFHelper_0123456789876543210 CF CH = FalseSym0 + TFHelper_0123456789876543210 CF CI = FalseSym0 + TFHelper_0123456789876543210 CF CJ = FalseSym0 + TFHelper_0123456789876543210 CF CK = FalseSym0 + TFHelper_0123456789876543210 CF CL = FalseSym0 + TFHelper_0123456789876543210 CF CM = FalseSym0 + TFHelper_0123456789876543210 CF CN = FalseSym0 + TFHelper_0123456789876543210 CF CO = FalseSym0 + TFHelper_0123456789876543210 CF CP = FalseSym0 + TFHelper_0123456789876543210 CF CQ = FalseSym0 + TFHelper_0123456789876543210 CF CR = FalseSym0 + TFHelper_0123456789876543210 CF CS = FalseSym0 + TFHelper_0123456789876543210 CF CT = FalseSym0 + TFHelper_0123456789876543210 CF CU = FalseSym0 + TFHelper_0123456789876543210 CF CV = FalseSym0 + TFHelper_0123456789876543210 CF CW = FalseSym0 + TFHelper_0123456789876543210 CF CX = FalseSym0 + TFHelper_0123456789876543210 CF CY = FalseSym0 + TFHelper_0123456789876543210 CF CZ = FalseSym0 + TFHelper_0123456789876543210 CG CA = FalseSym0 + TFHelper_0123456789876543210 CG CB = FalseSym0 + TFHelper_0123456789876543210 CG CC = FalseSym0 + TFHelper_0123456789876543210 CG CD = FalseSym0 + TFHelper_0123456789876543210 CG CE = FalseSym0 + TFHelper_0123456789876543210 CG CF = FalseSym0 + TFHelper_0123456789876543210 CG CG = TrueSym0 + TFHelper_0123456789876543210 CG CH = FalseSym0 + TFHelper_0123456789876543210 CG CI = FalseSym0 + TFHelper_0123456789876543210 CG CJ = FalseSym0 + TFHelper_0123456789876543210 CG CK = FalseSym0 + TFHelper_0123456789876543210 CG CL = FalseSym0 + TFHelper_0123456789876543210 CG CM = FalseSym0 + TFHelper_0123456789876543210 CG CN = FalseSym0 + TFHelper_0123456789876543210 CG CO = FalseSym0 + TFHelper_0123456789876543210 CG CP = FalseSym0 + TFHelper_0123456789876543210 CG CQ = FalseSym0 + TFHelper_0123456789876543210 CG CR = FalseSym0 + TFHelper_0123456789876543210 CG CS = FalseSym0 + TFHelper_0123456789876543210 CG CT = FalseSym0 + TFHelper_0123456789876543210 CG CU = FalseSym0 + TFHelper_0123456789876543210 CG CV = FalseSym0 + TFHelper_0123456789876543210 CG CW = FalseSym0 + TFHelper_0123456789876543210 CG CX = FalseSym0 + TFHelper_0123456789876543210 CG CY = FalseSym0 + TFHelper_0123456789876543210 CG CZ = FalseSym0 + TFHelper_0123456789876543210 CH CA = FalseSym0 + TFHelper_0123456789876543210 CH CB = FalseSym0 + TFHelper_0123456789876543210 CH CC = FalseSym0 + TFHelper_0123456789876543210 CH CD = FalseSym0 + TFHelper_0123456789876543210 CH CE = FalseSym0 + TFHelper_0123456789876543210 CH CF = FalseSym0 + TFHelper_0123456789876543210 CH CG = FalseSym0 + TFHelper_0123456789876543210 CH CH = TrueSym0 + TFHelper_0123456789876543210 CH CI = FalseSym0 + TFHelper_0123456789876543210 CH CJ = FalseSym0 + TFHelper_0123456789876543210 CH CK = FalseSym0 + TFHelper_0123456789876543210 CH CL = FalseSym0 + TFHelper_0123456789876543210 CH CM = FalseSym0 + TFHelper_0123456789876543210 CH CN = FalseSym0 + TFHelper_0123456789876543210 CH CO = FalseSym0 + TFHelper_0123456789876543210 CH CP = FalseSym0 + TFHelper_0123456789876543210 CH CQ = FalseSym0 + TFHelper_0123456789876543210 CH CR = FalseSym0 + TFHelper_0123456789876543210 CH CS = FalseSym0 + TFHelper_0123456789876543210 CH CT = FalseSym0 + TFHelper_0123456789876543210 CH CU = FalseSym0 + TFHelper_0123456789876543210 CH CV = FalseSym0 + TFHelper_0123456789876543210 CH CW = FalseSym0 + TFHelper_0123456789876543210 CH CX = FalseSym0 + TFHelper_0123456789876543210 CH CY = FalseSym0 + TFHelper_0123456789876543210 CH CZ = FalseSym0 + TFHelper_0123456789876543210 CI CA = FalseSym0 + TFHelper_0123456789876543210 CI CB = FalseSym0 + TFHelper_0123456789876543210 CI CC = FalseSym0 + TFHelper_0123456789876543210 CI CD = FalseSym0 + TFHelper_0123456789876543210 CI CE = FalseSym0 + TFHelper_0123456789876543210 CI CF = FalseSym0 + TFHelper_0123456789876543210 CI CG = FalseSym0 + TFHelper_0123456789876543210 CI CH = FalseSym0 + TFHelper_0123456789876543210 CI CI = TrueSym0 + TFHelper_0123456789876543210 CI CJ = FalseSym0 + TFHelper_0123456789876543210 CI CK = FalseSym0 + TFHelper_0123456789876543210 CI CL = FalseSym0 + TFHelper_0123456789876543210 CI CM = FalseSym0 + TFHelper_0123456789876543210 CI CN = FalseSym0 + TFHelper_0123456789876543210 CI CO = FalseSym0 + TFHelper_0123456789876543210 CI CP = FalseSym0 + TFHelper_0123456789876543210 CI CQ = FalseSym0 + TFHelper_0123456789876543210 CI CR = FalseSym0 + TFHelper_0123456789876543210 CI CS = FalseSym0 + TFHelper_0123456789876543210 CI CT = FalseSym0 + TFHelper_0123456789876543210 CI CU = FalseSym0 + TFHelper_0123456789876543210 CI CV = FalseSym0 + TFHelper_0123456789876543210 CI CW = FalseSym0 + TFHelper_0123456789876543210 CI CX = FalseSym0 + TFHelper_0123456789876543210 CI CY = FalseSym0 + TFHelper_0123456789876543210 CI CZ = FalseSym0 + TFHelper_0123456789876543210 CJ CA = FalseSym0 + TFHelper_0123456789876543210 CJ CB = FalseSym0 + TFHelper_0123456789876543210 CJ CC = FalseSym0 + TFHelper_0123456789876543210 CJ CD = FalseSym0 + TFHelper_0123456789876543210 CJ CE = FalseSym0 + TFHelper_0123456789876543210 CJ CF = FalseSym0 + TFHelper_0123456789876543210 CJ CG = FalseSym0 + TFHelper_0123456789876543210 CJ CH = FalseSym0 + TFHelper_0123456789876543210 CJ CI = FalseSym0 + TFHelper_0123456789876543210 CJ CJ = TrueSym0 + TFHelper_0123456789876543210 CJ CK = FalseSym0 + TFHelper_0123456789876543210 CJ CL = FalseSym0 + TFHelper_0123456789876543210 CJ CM = FalseSym0 + TFHelper_0123456789876543210 CJ CN = FalseSym0 + TFHelper_0123456789876543210 CJ CO = FalseSym0 + TFHelper_0123456789876543210 CJ CP = FalseSym0 + TFHelper_0123456789876543210 CJ CQ = FalseSym0 + TFHelper_0123456789876543210 CJ CR = FalseSym0 + TFHelper_0123456789876543210 CJ CS = FalseSym0 + TFHelper_0123456789876543210 CJ CT = FalseSym0 + TFHelper_0123456789876543210 CJ CU = FalseSym0 + TFHelper_0123456789876543210 CJ CV = FalseSym0 + TFHelper_0123456789876543210 CJ CW = FalseSym0 + TFHelper_0123456789876543210 CJ CX = FalseSym0 + TFHelper_0123456789876543210 CJ CY = FalseSym0 + TFHelper_0123456789876543210 CJ CZ = FalseSym0 + TFHelper_0123456789876543210 CK CA = FalseSym0 + TFHelper_0123456789876543210 CK CB = FalseSym0 + TFHelper_0123456789876543210 CK CC = FalseSym0 + TFHelper_0123456789876543210 CK CD = FalseSym0 + TFHelper_0123456789876543210 CK CE = FalseSym0 + TFHelper_0123456789876543210 CK CF = FalseSym0 + TFHelper_0123456789876543210 CK CG = FalseSym0 + TFHelper_0123456789876543210 CK CH = FalseSym0 + TFHelper_0123456789876543210 CK CI = FalseSym0 + TFHelper_0123456789876543210 CK CJ = FalseSym0 + TFHelper_0123456789876543210 CK CK = TrueSym0 + TFHelper_0123456789876543210 CK CL = FalseSym0 + TFHelper_0123456789876543210 CK CM = FalseSym0 + TFHelper_0123456789876543210 CK CN = FalseSym0 + TFHelper_0123456789876543210 CK CO = FalseSym0 + TFHelper_0123456789876543210 CK CP = FalseSym0 + TFHelper_0123456789876543210 CK CQ = FalseSym0 + TFHelper_0123456789876543210 CK CR = FalseSym0 + TFHelper_0123456789876543210 CK CS = FalseSym0 + TFHelper_0123456789876543210 CK CT = FalseSym0 + TFHelper_0123456789876543210 CK CU = FalseSym0 + TFHelper_0123456789876543210 CK CV = FalseSym0 + TFHelper_0123456789876543210 CK CW = FalseSym0 + TFHelper_0123456789876543210 CK CX = FalseSym0 + TFHelper_0123456789876543210 CK CY = FalseSym0 + TFHelper_0123456789876543210 CK CZ = FalseSym0 + TFHelper_0123456789876543210 CL CA = FalseSym0 + TFHelper_0123456789876543210 CL CB = FalseSym0 + TFHelper_0123456789876543210 CL CC = FalseSym0 + TFHelper_0123456789876543210 CL CD = FalseSym0 + TFHelper_0123456789876543210 CL CE = FalseSym0 + TFHelper_0123456789876543210 CL CF = FalseSym0 + TFHelper_0123456789876543210 CL CG = FalseSym0 + TFHelper_0123456789876543210 CL CH = FalseSym0 + TFHelper_0123456789876543210 CL CI = FalseSym0 + TFHelper_0123456789876543210 CL CJ = FalseSym0 + TFHelper_0123456789876543210 CL CK = FalseSym0 + TFHelper_0123456789876543210 CL CL = TrueSym0 + TFHelper_0123456789876543210 CL CM = FalseSym0 + TFHelper_0123456789876543210 CL CN = FalseSym0 + TFHelper_0123456789876543210 CL CO = FalseSym0 + TFHelper_0123456789876543210 CL CP = FalseSym0 + TFHelper_0123456789876543210 CL CQ = FalseSym0 + TFHelper_0123456789876543210 CL CR = FalseSym0 + TFHelper_0123456789876543210 CL CS = FalseSym0 + TFHelper_0123456789876543210 CL CT = FalseSym0 + TFHelper_0123456789876543210 CL CU = FalseSym0 + TFHelper_0123456789876543210 CL CV = FalseSym0 + TFHelper_0123456789876543210 CL CW = FalseSym0 + TFHelper_0123456789876543210 CL CX = FalseSym0 + TFHelper_0123456789876543210 CL CY = FalseSym0 + TFHelper_0123456789876543210 CL CZ = FalseSym0 + TFHelper_0123456789876543210 CM CA = FalseSym0 + TFHelper_0123456789876543210 CM CB = FalseSym0 + TFHelper_0123456789876543210 CM CC = FalseSym0 + TFHelper_0123456789876543210 CM CD = FalseSym0 + TFHelper_0123456789876543210 CM CE = FalseSym0 + TFHelper_0123456789876543210 CM CF = FalseSym0 + TFHelper_0123456789876543210 CM CG = FalseSym0 + TFHelper_0123456789876543210 CM CH = FalseSym0 + TFHelper_0123456789876543210 CM CI = FalseSym0 + TFHelper_0123456789876543210 CM CJ = FalseSym0 + TFHelper_0123456789876543210 CM CK = FalseSym0 + TFHelper_0123456789876543210 CM CL = FalseSym0 + TFHelper_0123456789876543210 CM CM = TrueSym0 + TFHelper_0123456789876543210 CM CN = FalseSym0 + TFHelper_0123456789876543210 CM CO = FalseSym0 + TFHelper_0123456789876543210 CM CP = FalseSym0 + TFHelper_0123456789876543210 CM CQ = FalseSym0 + TFHelper_0123456789876543210 CM CR = FalseSym0 + TFHelper_0123456789876543210 CM CS = FalseSym0 + TFHelper_0123456789876543210 CM CT = FalseSym0 + TFHelper_0123456789876543210 CM CU = FalseSym0 + TFHelper_0123456789876543210 CM CV = FalseSym0 + TFHelper_0123456789876543210 CM CW = FalseSym0 + TFHelper_0123456789876543210 CM CX = FalseSym0 + TFHelper_0123456789876543210 CM CY = FalseSym0 + TFHelper_0123456789876543210 CM CZ = FalseSym0 + TFHelper_0123456789876543210 CN CA = FalseSym0 + TFHelper_0123456789876543210 CN CB = FalseSym0 + TFHelper_0123456789876543210 CN CC = FalseSym0 + TFHelper_0123456789876543210 CN CD = FalseSym0 + TFHelper_0123456789876543210 CN CE = FalseSym0 + TFHelper_0123456789876543210 CN CF = FalseSym0 + TFHelper_0123456789876543210 CN CG = FalseSym0 + TFHelper_0123456789876543210 CN CH = FalseSym0 + TFHelper_0123456789876543210 CN CI = FalseSym0 + TFHelper_0123456789876543210 CN CJ = FalseSym0 + TFHelper_0123456789876543210 CN CK = FalseSym0 + TFHelper_0123456789876543210 CN CL = FalseSym0 + TFHelper_0123456789876543210 CN CM = FalseSym0 + TFHelper_0123456789876543210 CN CN = TrueSym0 + TFHelper_0123456789876543210 CN CO = FalseSym0 + TFHelper_0123456789876543210 CN CP = FalseSym0 + TFHelper_0123456789876543210 CN CQ = FalseSym0 + TFHelper_0123456789876543210 CN CR = FalseSym0 + TFHelper_0123456789876543210 CN CS = FalseSym0 + TFHelper_0123456789876543210 CN CT = FalseSym0 + TFHelper_0123456789876543210 CN CU = FalseSym0 + TFHelper_0123456789876543210 CN CV = FalseSym0 + TFHelper_0123456789876543210 CN CW = FalseSym0 + TFHelper_0123456789876543210 CN CX = FalseSym0 + TFHelper_0123456789876543210 CN CY = FalseSym0 + TFHelper_0123456789876543210 CN CZ = FalseSym0 + TFHelper_0123456789876543210 CO CA = FalseSym0 + TFHelper_0123456789876543210 CO CB = FalseSym0 + TFHelper_0123456789876543210 CO CC = FalseSym0 + TFHelper_0123456789876543210 CO CD = FalseSym0 + TFHelper_0123456789876543210 CO CE = FalseSym0 + TFHelper_0123456789876543210 CO CF = FalseSym0 + TFHelper_0123456789876543210 CO CG = FalseSym0 + TFHelper_0123456789876543210 CO CH = FalseSym0 + TFHelper_0123456789876543210 CO CI = FalseSym0 + TFHelper_0123456789876543210 CO CJ = FalseSym0 + TFHelper_0123456789876543210 CO CK = FalseSym0 + TFHelper_0123456789876543210 CO CL = FalseSym0 + TFHelper_0123456789876543210 CO CM = FalseSym0 + TFHelper_0123456789876543210 CO CN = FalseSym0 + TFHelper_0123456789876543210 CO CO = TrueSym0 + TFHelper_0123456789876543210 CO CP = FalseSym0 + TFHelper_0123456789876543210 CO CQ = FalseSym0 + TFHelper_0123456789876543210 CO CR = FalseSym0 + TFHelper_0123456789876543210 CO CS = FalseSym0 + TFHelper_0123456789876543210 CO CT = FalseSym0 + TFHelper_0123456789876543210 CO CU = FalseSym0 + TFHelper_0123456789876543210 CO CV = FalseSym0 + TFHelper_0123456789876543210 CO CW = FalseSym0 + TFHelper_0123456789876543210 CO CX = FalseSym0 + TFHelper_0123456789876543210 CO CY = FalseSym0 + TFHelper_0123456789876543210 CO CZ = FalseSym0 + TFHelper_0123456789876543210 CP CA = FalseSym0 + TFHelper_0123456789876543210 CP CB = FalseSym0 + TFHelper_0123456789876543210 CP CC = FalseSym0 + TFHelper_0123456789876543210 CP CD = FalseSym0 + TFHelper_0123456789876543210 CP CE = FalseSym0 + TFHelper_0123456789876543210 CP CF = FalseSym0 + TFHelper_0123456789876543210 CP CG = FalseSym0 + TFHelper_0123456789876543210 CP CH = FalseSym0 + TFHelper_0123456789876543210 CP CI = FalseSym0 + TFHelper_0123456789876543210 CP CJ = FalseSym0 + TFHelper_0123456789876543210 CP CK = FalseSym0 + TFHelper_0123456789876543210 CP CL = FalseSym0 + TFHelper_0123456789876543210 CP CM = FalseSym0 + TFHelper_0123456789876543210 CP CN = FalseSym0 + TFHelper_0123456789876543210 CP CO = FalseSym0 + TFHelper_0123456789876543210 CP CP = TrueSym0 + TFHelper_0123456789876543210 CP CQ = FalseSym0 + TFHelper_0123456789876543210 CP CR = FalseSym0 + TFHelper_0123456789876543210 CP CS = FalseSym0 + TFHelper_0123456789876543210 CP CT = FalseSym0 + TFHelper_0123456789876543210 CP CU = FalseSym0 + TFHelper_0123456789876543210 CP CV = FalseSym0 + TFHelper_0123456789876543210 CP CW = FalseSym0 + TFHelper_0123456789876543210 CP CX = FalseSym0 + TFHelper_0123456789876543210 CP CY = FalseSym0 + TFHelper_0123456789876543210 CP CZ = FalseSym0 + TFHelper_0123456789876543210 CQ CA = FalseSym0 + TFHelper_0123456789876543210 CQ CB = FalseSym0 + TFHelper_0123456789876543210 CQ CC = FalseSym0 + TFHelper_0123456789876543210 CQ CD = FalseSym0 + TFHelper_0123456789876543210 CQ CE = FalseSym0 + TFHelper_0123456789876543210 CQ CF = FalseSym0 + TFHelper_0123456789876543210 CQ CG = FalseSym0 + TFHelper_0123456789876543210 CQ CH = FalseSym0 + TFHelper_0123456789876543210 CQ CI = FalseSym0 + TFHelper_0123456789876543210 CQ CJ = FalseSym0 + TFHelper_0123456789876543210 CQ CK = FalseSym0 + TFHelper_0123456789876543210 CQ CL = FalseSym0 + TFHelper_0123456789876543210 CQ CM = FalseSym0 + TFHelper_0123456789876543210 CQ CN = FalseSym0 + TFHelper_0123456789876543210 CQ CO = FalseSym0 + TFHelper_0123456789876543210 CQ CP = FalseSym0 + TFHelper_0123456789876543210 CQ CQ = TrueSym0 + TFHelper_0123456789876543210 CQ CR = FalseSym0 + TFHelper_0123456789876543210 CQ CS = FalseSym0 + TFHelper_0123456789876543210 CQ CT = FalseSym0 + TFHelper_0123456789876543210 CQ CU = FalseSym0 + TFHelper_0123456789876543210 CQ CV = FalseSym0 + TFHelper_0123456789876543210 CQ CW = FalseSym0 + TFHelper_0123456789876543210 CQ CX = FalseSym0 + TFHelper_0123456789876543210 CQ CY = FalseSym0 + TFHelper_0123456789876543210 CQ CZ = FalseSym0 + TFHelper_0123456789876543210 CR CA = FalseSym0 + TFHelper_0123456789876543210 CR CB = FalseSym0 + TFHelper_0123456789876543210 CR CC = FalseSym0 + TFHelper_0123456789876543210 CR CD = FalseSym0 + TFHelper_0123456789876543210 CR CE = FalseSym0 + TFHelper_0123456789876543210 CR CF = FalseSym0 + TFHelper_0123456789876543210 CR CG = FalseSym0 + TFHelper_0123456789876543210 CR CH = FalseSym0 + TFHelper_0123456789876543210 CR CI = FalseSym0 + TFHelper_0123456789876543210 CR CJ = FalseSym0 + TFHelper_0123456789876543210 CR CK = FalseSym0 + TFHelper_0123456789876543210 CR CL = FalseSym0 + TFHelper_0123456789876543210 CR CM = FalseSym0 + TFHelper_0123456789876543210 CR CN = FalseSym0 + TFHelper_0123456789876543210 CR CO = FalseSym0 + TFHelper_0123456789876543210 CR CP = FalseSym0 + TFHelper_0123456789876543210 CR CQ = FalseSym0 + TFHelper_0123456789876543210 CR CR = TrueSym0 + TFHelper_0123456789876543210 CR CS = FalseSym0 + TFHelper_0123456789876543210 CR CT = FalseSym0 + TFHelper_0123456789876543210 CR CU = FalseSym0 + TFHelper_0123456789876543210 CR CV = FalseSym0 + TFHelper_0123456789876543210 CR CW = FalseSym0 + TFHelper_0123456789876543210 CR CX = FalseSym0 + TFHelper_0123456789876543210 CR CY = FalseSym0 + TFHelper_0123456789876543210 CR CZ = FalseSym0 + TFHelper_0123456789876543210 CS CA = FalseSym0 + TFHelper_0123456789876543210 CS CB = FalseSym0 + TFHelper_0123456789876543210 CS CC = FalseSym0 + TFHelper_0123456789876543210 CS CD = FalseSym0 + TFHelper_0123456789876543210 CS CE = FalseSym0 + TFHelper_0123456789876543210 CS CF = FalseSym0 + TFHelper_0123456789876543210 CS CG = FalseSym0 + TFHelper_0123456789876543210 CS CH = FalseSym0 + TFHelper_0123456789876543210 CS CI = FalseSym0 + TFHelper_0123456789876543210 CS CJ = FalseSym0 + TFHelper_0123456789876543210 CS CK = FalseSym0 + TFHelper_0123456789876543210 CS CL = FalseSym0 + TFHelper_0123456789876543210 CS CM = FalseSym0 + TFHelper_0123456789876543210 CS CN = FalseSym0 + TFHelper_0123456789876543210 CS CO = FalseSym0 + TFHelper_0123456789876543210 CS CP = FalseSym0 + TFHelper_0123456789876543210 CS CQ = FalseSym0 + TFHelper_0123456789876543210 CS CR = FalseSym0 + TFHelper_0123456789876543210 CS CS = TrueSym0 + TFHelper_0123456789876543210 CS CT = FalseSym0 + TFHelper_0123456789876543210 CS CU = FalseSym0 + TFHelper_0123456789876543210 CS CV = FalseSym0 + TFHelper_0123456789876543210 CS CW = FalseSym0 + TFHelper_0123456789876543210 CS CX = FalseSym0 + TFHelper_0123456789876543210 CS CY = FalseSym0 + TFHelper_0123456789876543210 CS CZ = FalseSym0 + TFHelper_0123456789876543210 CT CA = FalseSym0 + TFHelper_0123456789876543210 CT CB = FalseSym0 + TFHelper_0123456789876543210 CT CC = FalseSym0 + TFHelper_0123456789876543210 CT CD = FalseSym0 + TFHelper_0123456789876543210 CT CE = FalseSym0 + TFHelper_0123456789876543210 CT CF = FalseSym0 + TFHelper_0123456789876543210 CT CG = FalseSym0 + TFHelper_0123456789876543210 CT CH = FalseSym0 + TFHelper_0123456789876543210 CT CI = FalseSym0 + TFHelper_0123456789876543210 CT CJ = FalseSym0 + TFHelper_0123456789876543210 CT CK = FalseSym0 + TFHelper_0123456789876543210 CT CL = FalseSym0 + TFHelper_0123456789876543210 CT CM = FalseSym0 + TFHelper_0123456789876543210 CT CN = FalseSym0 + TFHelper_0123456789876543210 CT CO = FalseSym0 + TFHelper_0123456789876543210 CT CP = FalseSym0 + TFHelper_0123456789876543210 CT CQ = FalseSym0 + TFHelper_0123456789876543210 CT CR = FalseSym0 + TFHelper_0123456789876543210 CT CS = FalseSym0 + TFHelper_0123456789876543210 CT CT = TrueSym0 + TFHelper_0123456789876543210 CT CU = FalseSym0 + TFHelper_0123456789876543210 CT CV = FalseSym0 + TFHelper_0123456789876543210 CT CW = FalseSym0 + TFHelper_0123456789876543210 CT CX = FalseSym0 + TFHelper_0123456789876543210 CT CY = FalseSym0 + TFHelper_0123456789876543210 CT CZ = FalseSym0 + TFHelper_0123456789876543210 CU CA = FalseSym0 + TFHelper_0123456789876543210 CU CB = FalseSym0 + TFHelper_0123456789876543210 CU CC = FalseSym0 + TFHelper_0123456789876543210 CU CD = FalseSym0 + TFHelper_0123456789876543210 CU CE = FalseSym0 + TFHelper_0123456789876543210 CU CF = FalseSym0 + TFHelper_0123456789876543210 CU CG = FalseSym0 + TFHelper_0123456789876543210 CU CH = FalseSym0 + TFHelper_0123456789876543210 CU CI = FalseSym0 + TFHelper_0123456789876543210 CU CJ = FalseSym0 + TFHelper_0123456789876543210 CU CK = FalseSym0 + TFHelper_0123456789876543210 CU CL = FalseSym0 + TFHelper_0123456789876543210 CU CM = FalseSym0 + TFHelper_0123456789876543210 CU CN = FalseSym0 + TFHelper_0123456789876543210 CU CO = FalseSym0 + TFHelper_0123456789876543210 CU CP = FalseSym0 + TFHelper_0123456789876543210 CU CQ = FalseSym0 + TFHelper_0123456789876543210 CU CR = FalseSym0 + TFHelper_0123456789876543210 CU CS = FalseSym0 + TFHelper_0123456789876543210 CU CT = FalseSym0 + TFHelper_0123456789876543210 CU CU = TrueSym0 + TFHelper_0123456789876543210 CU CV = FalseSym0 + TFHelper_0123456789876543210 CU CW = FalseSym0 + TFHelper_0123456789876543210 CU CX = FalseSym0 + TFHelper_0123456789876543210 CU CY = FalseSym0 + TFHelper_0123456789876543210 CU CZ = FalseSym0 + TFHelper_0123456789876543210 CV CA = FalseSym0 + TFHelper_0123456789876543210 CV CB = FalseSym0 + TFHelper_0123456789876543210 CV CC = FalseSym0 + TFHelper_0123456789876543210 CV CD = FalseSym0 + TFHelper_0123456789876543210 CV CE = FalseSym0 + TFHelper_0123456789876543210 CV CF = FalseSym0 + TFHelper_0123456789876543210 CV CG = FalseSym0 + TFHelper_0123456789876543210 CV CH = FalseSym0 + TFHelper_0123456789876543210 CV CI = FalseSym0 + TFHelper_0123456789876543210 CV CJ = FalseSym0 + TFHelper_0123456789876543210 CV CK = FalseSym0 + TFHelper_0123456789876543210 CV CL = FalseSym0 + TFHelper_0123456789876543210 CV CM = FalseSym0 + TFHelper_0123456789876543210 CV CN = FalseSym0 + TFHelper_0123456789876543210 CV CO = FalseSym0 + TFHelper_0123456789876543210 CV CP = FalseSym0 + TFHelper_0123456789876543210 CV CQ = FalseSym0 + TFHelper_0123456789876543210 CV CR = FalseSym0 + TFHelper_0123456789876543210 CV CS = FalseSym0 + TFHelper_0123456789876543210 CV CT = FalseSym0 + TFHelper_0123456789876543210 CV CU = FalseSym0 + TFHelper_0123456789876543210 CV CV = TrueSym0 + TFHelper_0123456789876543210 CV CW = FalseSym0 + TFHelper_0123456789876543210 CV CX = FalseSym0 + TFHelper_0123456789876543210 CV CY = FalseSym0 + TFHelper_0123456789876543210 CV CZ = FalseSym0 + TFHelper_0123456789876543210 CW CA = FalseSym0 + TFHelper_0123456789876543210 CW CB = FalseSym0 + TFHelper_0123456789876543210 CW CC = FalseSym0 + TFHelper_0123456789876543210 CW CD = FalseSym0 + TFHelper_0123456789876543210 CW CE = FalseSym0 + TFHelper_0123456789876543210 CW CF = FalseSym0 + TFHelper_0123456789876543210 CW CG = FalseSym0 + TFHelper_0123456789876543210 CW CH = FalseSym0 + TFHelper_0123456789876543210 CW CI = FalseSym0 + TFHelper_0123456789876543210 CW CJ = FalseSym0 + TFHelper_0123456789876543210 CW CK = FalseSym0 + TFHelper_0123456789876543210 CW CL = FalseSym0 + TFHelper_0123456789876543210 CW CM = FalseSym0 + TFHelper_0123456789876543210 CW CN = FalseSym0 + TFHelper_0123456789876543210 CW CO = FalseSym0 + TFHelper_0123456789876543210 CW CP = FalseSym0 + TFHelper_0123456789876543210 CW CQ = FalseSym0 + TFHelper_0123456789876543210 CW CR = FalseSym0 + TFHelper_0123456789876543210 CW CS = FalseSym0 + TFHelper_0123456789876543210 CW CT = FalseSym0 + TFHelper_0123456789876543210 CW CU = FalseSym0 + TFHelper_0123456789876543210 CW CV = FalseSym0 + TFHelper_0123456789876543210 CW CW = TrueSym0 + TFHelper_0123456789876543210 CW CX = FalseSym0 + TFHelper_0123456789876543210 CW CY = FalseSym0 + TFHelper_0123456789876543210 CW CZ = FalseSym0 + TFHelper_0123456789876543210 CX CA = FalseSym0 + TFHelper_0123456789876543210 CX CB = FalseSym0 + TFHelper_0123456789876543210 CX CC = FalseSym0 + TFHelper_0123456789876543210 CX CD = FalseSym0 + TFHelper_0123456789876543210 CX CE = FalseSym0 + TFHelper_0123456789876543210 CX CF = FalseSym0 + TFHelper_0123456789876543210 CX CG = FalseSym0 + TFHelper_0123456789876543210 CX CH = FalseSym0 + TFHelper_0123456789876543210 CX CI = FalseSym0 + TFHelper_0123456789876543210 CX CJ = FalseSym0 + TFHelper_0123456789876543210 CX CK = FalseSym0 + TFHelper_0123456789876543210 CX CL = FalseSym0 + TFHelper_0123456789876543210 CX CM = FalseSym0 + TFHelper_0123456789876543210 CX CN = FalseSym0 + TFHelper_0123456789876543210 CX CO = FalseSym0 + TFHelper_0123456789876543210 CX CP = FalseSym0 + TFHelper_0123456789876543210 CX CQ = FalseSym0 + TFHelper_0123456789876543210 CX CR = FalseSym0 + TFHelper_0123456789876543210 CX CS = FalseSym0 + TFHelper_0123456789876543210 CX CT = FalseSym0 + TFHelper_0123456789876543210 CX CU = FalseSym0 + TFHelper_0123456789876543210 CX CV = FalseSym0 + TFHelper_0123456789876543210 CX CW = FalseSym0 + TFHelper_0123456789876543210 CX CX = TrueSym0 + TFHelper_0123456789876543210 CX CY = FalseSym0 + TFHelper_0123456789876543210 CX CZ = FalseSym0 + TFHelper_0123456789876543210 CY CA = FalseSym0 + TFHelper_0123456789876543210 CY CB = FalseSym0 + TFHelper_0123456789876543210 CY CC = FalseSym0 + TFHelper_0123456789876543210 CY CD = FalseSym0 + TFHelper_0123456789876543210 CY CE = FalseSym0 + TFHelper_0123456789876543210 CY CF = FalseSym0 + TFHelper_0123456789876543210 CY CG = FalseSym0 + TFHelper_0123456789876543210 CY CH = FalseSym0 + TFHelper_0123456789876543210 CY CI = FalseSym0 + TFHelper_0123456789876543210 CY CJ = FalseSym0 + TFHelper_0123456789876543210 CY CK = FalseSym0 + TFHelper_0123456789876543210 CY CL = FalseSym0 + TFHelper_0123456789876543210 CY CM = FalseSym0 + TFHelper_0123456789876543210 CY CN = FalseSym0 + TFHelper_0123456789876543210 CY CO = FalseSym0 + TFHelper_0123456789876543210 CY CP = FalseSym0 + TFHelper_0123456789876543210 CY CQ = FalseSym0 + TFHelper_0123456789876543210 CY CR = FalseSym0 + TFHelper_0123456789876543210 CY CS = FalseSym0 + TFHelper_0123456789876543210 CY CT = FalseSym0 + TFHelper_0123456789876543210 CY CU = FalseSym0 + TFHelper_0123456789876543210 CY CV = FalseSym0 + TFHelper_0123456789876543210 CY CW = FalseSym0 + TFHelper_0123456789876543210 CY CX = FalseSym0 + TFHelper_0123456789876543210 CY CY = TrueSym0 + TFHelper_0123456789876543210 CY CZ = FalseSym0 + TFHelper_0123456789876543210 CZ CA = FalseSym0 + TFHelper_0123456789876543210 CZ CB = FalseSym0 + TFHelper_0123456789876543210 CZ CC = FalseSym0 + TFHelper_0123456789876543210 CZ CD = FalseSym0 + TFHelper_0123456789876543210 CZ CE = FalseSym0 + TFHelper_0123456789876543210 CZ CF = FalseSym0 + TFHelper_0123456789876543210 CZ CG = FalseSym0 + TFHelper_0123456789876543210 CZ CH = FalseSym0 + TFHelper_0123456789876543210 CZ CI = FalseSym0 + TFHelper_0123456789876543210 CZ CJ = FalseSym0 + TFHelper_0123456789876543210 CZ CK = FalseSym0 + TFHelper_0123456789876543210 CZ CL = FalseSym0 + TFHelper_0123456789876543210 CZ CM = FalseSym0 + TFHelper_0123456789876543210 CZ CN = FalseSym0 + TFHelper_0123456789876543210 CZ CO = FalseSym0 + TFHelper_0123456789876543210 CZ CP = FalseSym0 + TFHelper_0123456789876543210 CZ CQ = FalseSym0 + TFHelper_0123456789876543210 CZ CR = FalseSym0 + TFHelper_0123456789876543210 CZ CS = FalseSym0 + TFHelper_0123456789876543210 CZ CT = FalseSym0 + TFHelper_0123456789876543210 CZ CU = FalseSym0 + TFHelper_0123456789876543210 CZ CV = FalseSym0 + TFHelper_0123456789876543210 CZ CW = FalseSym0 + TFHelper_0123456789876543210 CZ CX = FalseSym0 + TFHelper_0123456789876543210 CZ CY = FalseSym0 + TFHelper_0123456789876543210 CZ CZ = TrueSym0 + instance PEq AChar where + type (==) a a = TFHelper_0123456789876543210 a a + sLookup :: + (forall (t :: [AChar]) (t :: Schema). + Sing t -> Sing t -> Sing (Lookup t t :: U) :: Type) + sOccurs :: + (forall (t :: [AChar]) (t :: Schema). + Sing t -> Sing t -> Sing (Occurs t t :: Bool) :: Type) + sDisjoint :: + (forall (t :: Schema) (t :: Schema). + Sing t -> Sing t -> Sing (Disjoint t t :: Bool) :: Type) + sAttrNotIn :: + (forall (t :: Attribute) (t :: Schema). + Sing t -> Sing t -> Sing (AttrNotIn t t :: Bool) :: Type) + sAppend :: + (forall (t :: Schema) (t :: Schema). + Sing t -> Sing t -> Sing (Append t t :: Schema) :: Type) + sLookup _ (SSch SNil) = sUndefined + sLookup + (sName :: Sing name) + (SSch (SCons (SAttr (sName' :: Sing name') (sU :: Sing u)) + (sAttrs :: Sing attrs))) + = applySing + (singFun1 + @(LamCases_0123456789876543210Sym0 name name' u attrs) + (\cases + STrue -> sU + SFalse + -> applySing + (applySing (singFun2 @LookupSym0 sLookup) sName) + (applySing (singFun1 @SchSym0 SSch) sAttrs))) + (applySing (applySing (singFun2 @(==@#@$) (%==)) sName) sName') + sOccurs _ (SSch SNil) = SFalse + sOccurs + (sName :: Sing name) + (SSch (SCons (SAttr (sName' :: Sing name') _) + (sAttrs :: Sing attrs))) + = applySing + (applySing + (singFun2 @(||@#@$) (%||)) + (applySing (applySing (singFun2 @(==@#@$) (%==)) sName) sName')) + (applySing + (applySing (singFun2 @OccursSym0 sOccurs) sName) + (applySing (singFun1 @SchSym0 SSch) sAttrs)) + sDisjoint (SSch SNil) _ = STrue + sDisjoint + (SSch (SCons (sH :: Sing h) (sT :: Sing t))) + (sS :: Sing s) + = applySing + (applySing + (singFun2 @(&&@#@$) (%&&)) + (applySing (applySing (singFun2 @AttrNotInSym0 sAttrNotIn) sH) sS)) + (applySing + (applySing + (singFun2 @DisjointSym0 sDisjoint) + (applySing (singFun1 @SchSym0 SSch) sT)) + sS) + sAttrNotIn _ (SSch SNil) = STrue + sAttrNotIn + (SAttr (sName :: Sing name) (sU :: Sing u)) + (SSch (SCons (SAttr (sName' :: Sing name') _) (sT :: Sing t))) + = applySing + (applySing + (singFun2 @(&&@#@$) (%&&)) + (applySing (applySing (singFun2 @(/=@#@$) (%/=)) sName) sName')) + (applySing + (applySing + (singFun2 @AttrNotInSym0 sAttrNotIn) + (applySing (applySing (singFun2 @AttrSym0 SAttr) sName) sU)) + (applySing (singFun1 @SchSym0 SSch) sT)) + sAppend (SSch (sS1 :: Sing s1)) (SSch (sS2 :: Sing s2)) + = applySing + (singFun1 @SchSym0 SSch) + (applySing (applySing (singFun2 @(++@#@$) (%++)) sS1) sS2) + instance SingI (LookupSym0 :: (~>) [AChar] ((~>) Schema U)) where + sing = singFun2 @LookupSym0 sLookup + instance SingI d => + SingI (LookupSym1 (d :: [AChar]) :: (~>) Schema U) where + sing = singFun1 @(LookupSym1 (d :: [AChar])) (sLookup (sing @d)) + instance SingI1 (LookupSym1 :: [AChar] -> (~>) Schema U) where + liftSing (s :: Sing (d :: [AChar])) + = singFun1 @(LookupSym1 (d :: [AChar])) (sLookup s) + instance SingI (OccursSym0 :: (~>) [AChar] ((~>) Schema Bool)) where + sing = singFun2 @OccursSym0 sOccurs + instance SingI d => + SingI (OccursSym1 (d :: [AChar]) :: (~>) Schema Bool) where + sing = singFun1 @(OccursSym1 (d :: [AChar])) (sOccurs (sing @d)) + instance SingI1 (OccursSym1 :: [AChar] -> (~>) Schema Bool) where + liftSing (s :: Sing (d :: [AChar])) + = singFun1 @(OccursSym1 (d :: [AChar])) (sOccurs s) + instance SingI (DisjointSym0 :: (~>) Schema ((~>) Schema Bool)) where + sing = singFun2 @DisjointSym0 sDisjoint + instance SingI d => + SingI (DisjointSym1 (d :: Schema) :: (~>) Schema Bool) where + sing = singFun1 @(DisjointSym1 (d :: Schema)) (sDisjoint (sing @d)) + instance SingI1 (DisjointSym1 :: Schema -> (~>) Schema Bool) where + liftSing (s :: Sing (d :: Schema)) + = singFun1 @(DisjointSym1 (d :: Schema)) (sDisjoint s) + instance SingI (AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool)) where + sing = singFun2 @AttrNotInSym0 sAttrNotIn + instance SingI d => + SingI (AttrNotInSym1 (d :: Attribute) :: (~>) Schema Bool) where + sing + = singFun1 @(AttrNotInSym1 (d :: Attribute)) (sAttrNotIn (sing @d)) + instance SingI1 (AttrNotInSym1 :: Attribute + -> (~>) Schema Bool) where + liftSing (s :: Sing (d :: Attribute)) + = singFun1 @(AttrNotInSym1 (d :: Attribute)) (sAttrNotIn s) + instance SingI (AppendSym0 :: (~>) Schema ((~>) Schema Schema)) where + sing = singFun2 @AppendSym0 sAppend + instance SingI d => + SingI (AppendSym1 (d :: Schema) :: (~>) Schema Schema) where + sing = singFun1 @(AppendSym1 (d :: Schema)) (sAppend (sing @d)) + instance SingI1 (AppendSym1 :: Schema -> (~>) Schema Schema) where + liftSing (s :: Sing (d :: Schema)) + = singFun1 @(AppendSym1 (d :: Schema)) (sAppend s) + data SU :: U -> Type + where + SBOOL :: SU (BOOL :: U) + SSTRING :: SU (STRING :: U) + SNAT :: SU (NAT :: U) + SVEC :: forall (n :: U) (n :: Nat). + (Sing n) -> (Sing n) -> SU (VEC n n :: U) + type instance Sing @U = SU + instance SingKind U where + type Demote U = U + fromSing SBOOL = BOOL + fromSing SSTRING = STRING + fromSing SNAT = NAT + fromSing (SVEC b b) = VEC (fromSing b) (fromSing b) + toSing BOOL = SomeSing SBOOL + toSing STRING = SomeSing SSTRING + toSing NAT = SomeSing SNAT + toSing (VEC (b :: Demote U) (b :: Demote Nat)) + = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SVEC c c)) + (toSing b :: SomeSing U) (toSing b :: SomeSing Nat) + data SAChar :: AChar -> Type + where + SCA :: SAChar (CA :: AChar) + SCB :: SAChar (CB :: AChar) + SCC :: SAChar (CC :: AChar) + SCD :: SAChar (CD :: AChar) + SCE :: SAChar (CE :: AChar) + SCF :: SAChar (CF :: AChar) + SCG :: SAChar (CG :: AChar) + SCH :: SAChar (CH :: AChar) + SCI :: SAChar (CI :: AChar) + SCJ :: SAChar (CJ :: AChar) + SCK :: SAChar (CK :: AChar) + SCL :: SAChar (CL :: AChar) + SCM :: SAChar (CM :: AChar) + SCN :: SAChar (CN :: AChar) + SCO :: SAChar (CO :: AChar) + SCP :: SAChar (CP :: AChar) + SCQ :: SAChar (CQ :: AChar) + SCR :: SAChar (CR :: AChar) + SCS :: SAChar (CS :: AChar) + SCT :: SAChar (CT :: AChar) + SCU :: SAChar (CU :: AChar) + SCV :: SAChar (CV :: AChar) + SCW :: SAChar (CW :: AChar) + SCX :: SAChar (CX :: AChar) + SCY :: SAChar (CY :: AChar) + SCZ :: SAChar (CZ :: AChar) + type instance Sing @AChar = SAChar + instance SingKind AChar where + type Demote AChar = AChar + fromSing SCA = CA + fromSing SCB = CB + fromSing SCC = CC + fromSing SCD = CD + fromSing SCE = CE + fromSing SCF = CF + fromSing SCG = CG + fromSing SCH = CH + fromSing SCI = CI + fromSing SCJ = CJ + fromSing SCK = CK + fromSing SCL = CL + fromSing SCM = CM + fromSing SCN = CN + fromSing SCO = CO + fromSing SCP = CP + fromSing SCQ = CQ + fromSing SCR = CR + fromSing SCS = CS + fromSing SCT = CT + fromSing SCU = CU + fromSing SCV = CV + fromSing SCW = CW + fromSing SCX = CX + fromSing SCY = CY + fromSing SCZ = CZ + toSing CA = SomeSing SCA + toSing CB = SomeSing SCB + toSing CC = SomeSing SCC + toSing CD = SomeSing SCD + toSing CE = SomeSing SCE + toSing CF = SomeSing SCF + toSing CG = SomeSing SCG + toSing CH = SomeSing SCH + toSing CI = SomeSing SCI + toSing CJ = SomeSing SCJ + toSing CK = SomeSing SCK + toSing CL = SomeSing SCL + toSing CM = SomeSing SCM + toSing CN = SomeSing SCN + toSing CO = SomeSing SCO + toSing CP = SomeSing SCP + toSing CQ = SomeSing SCQ + toSing CR = SomeSing SCR + toSing CS = SomeSing SCS + toSing CT = SomeSing SCT + toSing CU = SomeSing SCU + toSing CV = SomeSing SCV + toSing CW = SomeSing SCW + toSing CX = SomeSing SCX + toSing CY = SomeSing SCY + toSing CZ = SomeSing SCZ + data SAttribute :: Attribute -> Type + where + SAttr :: forall (n :: [AChar]) (n :: U). + (Sing n) -> (Sing n) -> SAttribute (Attr n n :: Attribute) + type instance Sing @Attribute = SAttribute + instance SingKind Attribute where + type Demote Attribute = Attribute + fromSing (SAttr b b) = Attr (fromSing b) (fromSing b) + toSing (Attr (b :: Demote [AChar]) (b :: Demote U)) + = (\cases (SomeSing c) (SomeSing c) -> SomeSing (SAttr c c)) + (toSing b :: SomeSing [AChar]) (toSing b :: SomeSing U) + data SSchema :: Schema -> Type + where + SSch :: forall (n :: [Attribute]). + (Sing n) -> SSchema (Sch n :: Schema) + type instance Sing @Schema = SSchema + instance SingKind Schema where + type Demote Schema = Schema + fromSing (SSch b) = Sch (fromSing b) + toSing (Sch (b :: Demote [Attribute])) + = (\cases (SomeSing c) -> SomeSing (SSch c)) + (toSing b :: SomeSing [Attribute]) + instance (SEq U, SEq Nat) => SEq U where + (%==) SBOOL SBOOL = STrue + (%==) SBOOL SSTRING = SFalse + (%==) SBOOL SNAT = SFalse + (%==) SBOOL (SVEC _ _) = SFalse + (%==) SSTRING SBOOL = SFalse + (%==) SSTRING SSTRING = STrue + (%==) SSTRING SNAT = SFalse + (%==) SSTRING (SVEC _ _) = SFalse + (%==) SNAT SBOOL = SFalse + (%==) SNAT SSTRING = SFalse + (%==) SNAT SNAT = STrue + (%==) SNAT (SVEC _ _) = SFalse + (%==) (SVEC _ _) SBOOL = SFalse + (%==) (SVEC _ _) SSTRING = SFalse + (%==) (SVEC _ _) SNAT = SFalse + (%==) + (SVEC (sA_0123456789876543210 :: Sing a_0123456789876543210) + (sA_0123456789876543210 :: Sing a_0123456789876543210)) + (SVEC (sB_0123456789876543210 :: Sing b_0123456789876543210) + (sB_0123456789876543210 :: Sing b_0123456789876543210)) + = applySing + (applySing + (singFun2 @(&&@#@$) (%&&)) + (applySing + (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210) + sB_0123456789876543210)) + (applySing + (applySing (singFun2 @(==@#@$) (%==)) sA_0123456789876543210) + sB_0123456789876543210) + instance (SShow U, SShow Nat) => SShow U where + sShowsPrec + _ + SBOOL + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "BOOL")) + sA_0123456789876543210 + sShowsPrec + _ + SSTRING + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "STRING")) + sA_0123456789876543210 + sShowsPrec + _ + SNAT + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "NAT")) + sA_0123456789876543210 + sShowsPrec + (sP_0123456789876543210 :: Sing p_0123456789876543210) + (SVEC (sArg_0123456789876543210 :: Sing arg_0123456789876543210) + (sArg_0123456789876543210 :: Sing arg_0123456789876543210)) + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (applySing + (singFun3 @ShowParenSym0 sShowParen) + (applySing + (applySing (singFun2 @(>@#@$) (%>)) sP_0123456789876543210) + (sFromInteger (sing :: Sing 10)))) + (applySing + (applySing + (singFun3 @(.@#@$) (%.)) + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "VEC "))) + (applySing + (applySing + (singFun3 @(.@#@$) (%.)) + (applySing + (applySing + (singFun3 @ShowsPrecSym0 sShowsPrec) + (sFromInteger (sing :: Sing 11))) + sArg_0123456789876543210)) + (applySing + (applySing + (singFun3 @(.@#@$) (%.)) (singFun1 @ShowSpaceSym0 sShowSpace)) + (applySing + (applySing + (singFun3 @ShowsPrecSym0 sShowsPrec) + (sFromInteger (sing :: Sing 11))) + sArg_0123456789876543210))))) + sA_0123456789876543210 + instance SShow AChar where + sShowsPrec + _ + SCA + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CA")) + sA_0123456789876543210 + sShowsPrec + _ + SCB + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CB")) + sA_0123456789876543210 + sShowsPrec + _ + SCC + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CC")) + sA_0123456789876543210 + sShowsPrec + _ + SCD + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CD")) + sA_0123456789876543210 + sShowsPrec + _ + SCE + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CE")) + sA_0123456789876543210 + sShowsPrec + _ + SCF + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CF")) + sA_0123456789876543210 + sShowsPrec + _ + SCG + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CG")) + sA_0123456789876543210 + sShowsPrec + _ + SCH + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CH")) + sA_0123456789876543210 + sShowsPrec + _ + SCI + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CI")) + sA_0123456789876543210 + sShowsPrec + _ + SCJ + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CJ")) + sA_0123456789876543210 + sShowsPrec + _ + SCK + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CK")) + sA_0123456789876543210 + sShowsPrec + _ + SCL + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CL")) + sA_0123456789876543210 + sShowsPrec + _ + SCM + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CM")) + sA_0123456789876543210 + sShowsPrec + _ + SCN + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CN")) + sA_0123456789876543210 + sShowsPrec + _ + SCO + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CO")) + sA_0123456789876543210 + sShowsPrec + _ + SCP + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CP")) + sA_0123456789876543210 + sShowsPrec + _ + SCQ + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CQ")) + sA_0123456789876543210 + sShowsPrec + _ + SCR + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CR")) + sA_0123456789876543210 + sShowsPrec + _ + SCS + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CS")) + sA_0123456789876543210 + sShowsPrec + _ + SCT + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CT")) + sA_0123456789876543210 + sShowsPrec + _ + SCU + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CU")) + sA_0123456789876543210 + sShowsPrec + _ + SCV + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CV")) + sA_0123456789876543210 + sShowsPrec + _ + SCW + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CW")) + sA_0123456789876543210 + sShowsPrec + _ + SCX + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CX")) + sA_0123456789876543210 + sShowsPrec + _ + SCY + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CY")) + sA_0123456789876543210 + sShowsPrec + _ + SCZ + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = applySing + (applySing + (singFun2 @ShowStringSym0 sShowString) (sing :: Sing "CZ")) + sA_0123456789876543210 + instance SEq AChar where + (%==) SCA SCA = STrue + (%==) SCA SCB = SFalse + (%==) SCA SCC = SFalse + (%==) SCA SCD = SFalse + (%==) SCA SCE = SFalse + (%==) SCA SCF = SFalse + (%==) SCA SCG = SFalse + (%==) SCA SCH = SFalse + (%==) SCA SCI = SFalse + (%==) SCA SCJ = SFalse + (%==) SCA SCK = SFalse + (%==) SCA SCL = SFalse + (%==) SCA SCM = SFalse + (%==) SCA SCN = SFalse + (%==) SCA SCO = SFalse + (%==) SCA SCP = SFalse + (%==) SCA SCQ = SFalse + (%==) SCA SCR = SFalse + (%==) SCA SCS = SFalse + (%==) SCA SCT = SFalse + (%==) SCA SCU = SFalse + (%==) SCA SCV = SFalse + (%==) SCA SCW = SFalse + (%==) SCA SCX = SFalse + (%==) SCA SCY = SFalse + (%==) SCA SCZ = SFalse + (%==) SCB SCA = SFalse + (%==) SCB SCB = STrue + (%==) SCB SCC = SFalse + (%==) SCB SCD = SFalse + (%==) SCB SCE = SFalse + (%==) SCB SCF = SFalse + (%==) SCB SCG = SFalse + (%==) SCB SCH = SFalse + (%==) SCB SCI = SFalse + (%==) SCB SCJ = SFalse + (%==) SCB SCK = SFalse + (%==) SCB SCL = SFalse + (%==) SCB SCM = SFalse + (%==) SCB SCN = SFalse + (%==) SCB SCO = SFalse + (%==) SCB SCP = SFalse + (%==) SCB SCQ = SFalse + (%==) SCB SCR = SFalse + (%==) SCB SCS = SFalse + (%==) SCB SCT = SFalse + (%==) SCB SCU = SFalse + (%==) SCB SCV = SFalse + (%==) SCB SCW = SFalse + (%==) SCB SCX = SFalse + (%==) SCB SCY = SFalse + (%==) SCB SCZ = SFalse + (%==) SCC SCA = SFalse + (%==) SCC SCB = SFalse + (%==) SCC SCC = STrue + (%==) SCC SCD = SFalse + (%==) SCC SCE = SFalse + (%==) SCC SCF = SFalse + (%==) SCC SCG = SFalse + (%==) SCC SCH = SFalse + (%==) SCC SCI = SFalse + (%==) SCC SCJ = SFalse + (%==) SCC SCK = SFalse + (%==) SCC SCL = SFalse + (%==) SCC SCM = SFalse + (%==) SCC SCN = SFalse + (%==) SCC SCO = SFalse + (%==) SCC SCP = SFalse + (%==) SCC SCQ = SFalse + (%==) SCC SCR = SFalse + (%==) SCC SCS = SFalse + (%==) SCC SCT = SFalse + (%==) SCC SCU = SFalse + (%==) SCC SCV = SFalse + (%==) SCC SCW = SFalse + (%==) SCC SCX = SFalse + (%==) SCC SCY = SFalse + (%==) SCC SCZ = SFalse + (%==) SCD SCA = SFalse + (%==) SCD SCB = SFalse + (%==) SCD SCC = SFalse + (%==) SCD SCD = STrue + (%==) SCD SCE = SFalse + (%==) SCD SCF = SFalse + (%==) SCD SCG = SFalse + (%==) SCD SCH = SFalse + (%==) SCD SCI = SFalse + (%==) SCD SCJ = SFalse + (%==) SCD SCK = SFalse + (%==) SCD SCL = SFalse + (%==) SCD SCM = SFalse + (%==) SCD SCN = SFalse + (%==) SCD SCO = SFalse + (%==) SCD SCP = SFalse + (%==) SCD SCQ = SFalse + (%==) SCD SCR = SFalse + (%==) SCD SCS = SFalse + (%==) SCD SCT = SFalse + (%==) SCD SCU = SFalse + (%==) SCD SCV = SFalse + (%==) SCD SCW = SFalse + (%==) SCD SCX = SFalse + (%==) SCD SCY = SFalse + (%==) SCD SCZ = SFalse + (%==) SCE SCA = SFalse + (%==) SCE SCB = SFalse + (%==) SCE SCC = SFalse + (%==) SCE SCD = SFalse + (%==) SCE SCE = STrue + (%==) SCE SCF = SFalse + (%==) SCE SCG = SFalse + (%==) SCE SCH = SFalse + (%==) SCE SCI = SFalse + (%==) SCE SCJ = SFalse + (%==) SCE SCK = SFalse + (%==) SCE SCL = SFalse + (%==) SCE SCM = SFalse + (%==) SCE SCN = SFalse + (%==) SCE SCO = SFalse + (%==) SCE SCP = SFalse + (%==) SCE SCQ = SFalse + (%==) SCE SCR = SFalse + (%==) SCE SCS = SFalse + (%==) SCE SCT = SFalse + (%==) SCE SCU = SFalse + (%==) SCE SCV = SFalse + (%==) SCE SCW = SFalse + (%==) SCE SCX = SFalse + (%==) SCE SCY = SFalse + (%==) SCE SCZ = SFalse + (%==) SCF SCA = SFalse + (%==) SCF SCB = SFalse + (%==) SCF SCC = SFalse + (%==) SCF SCD = SFalse + (%==) SCF SCE = SFalse + (%==) SCF SCF = STrue + (%==) SCF SCG = SFalse + (%==) SCF SCH = SFalse + (%==) SCF SCI = SFalse + (%==) SCF SCJ = SFalse + (%==) SCF SCK = SFalse + (%==) SCF SCL = SFalse + (%==) SCF SCM = SFalse + (%==) SCF SCN = SFalse + (%==) SCF SCO = SFalse + (%==) SCF SCP = SFalse + (%==) SCF SCQ = SFalse + (%==) SCF SCR = SFalse + (%==) SCF SCS = SFalse + (%==) SCF SCT = SFalse + (%==) SCF SCU = SFalse + (%==) SCF SCV = SFalse + (%==) SCF SCW = SFalse + (%==) SCF SCX = SFalse + (%==) SCF SCY = SFalse + (%==) SCF SCZ = SFalse + (%==) SCG SCA = SFalse + (%==) SCG SCB = SFalse + (%==) SCG SCC = SFalse + (%==) SCG SCD = SFalse + (%==) SCG SCE = SFalse + (%==) SCG SCF = SFalse + (%==) SCG SCG = STrue + (%==) SCG SCH = SFalse + (%==) SCG SCI = SFalse + (%==) SCG SCJ = SFalse + (%==) SCG SCK = SFalse + (%==) SCG SCL = SFalse + (%==) SCG SCM = SFalse + (%==) SCG SCN = SFalse + (%==) SCG SCO = SFalse + (%==) SCG SCP = SFalse + (%==) SCG SCQ = SFalse + (%==) SCG SCR = SFalse + (%==) SCG SCS = SFalse + (%==) SCG SCT = SFalse + (%==) SCG SCU = SFalse + (%==) SCG SCV = SFalse + (%==) SCG SCW = SFalse + (%==) SCG SCX = SFalse + (%==) SCG SCY = SFalse + (%==) SCG SCZ = SFalse + (%==) SCH SCA = SFalse + (%==) SCH SCB = SFalse + (%==) SCH SCC = SFalse + (%==) SCH SCD = SFalse + (%==) SCH SCE = SFalse + (%==) SCH SCF = SFalse + (%==) SCH SCG = SFalse + (%==) SCH SCH = STrue + (%==) SCH SCI = SFalse + (%==) SCH SCJ = SFalse + (%==) SCH SCK = SFalse + (%==) SCH SCL = SFalse + (%==) SCH SCM = SFalse + (%==) SCH SCN = SFalse + (%==) SCH SCO = SFalse + (%==) SCH SCP = SFalse + (%==) SCH SCQ = SFalse + (%==) SCH SCR = SFalse + (%==) SCH SCS = SFalse + (%==) SCH SCT = SFalse + (%==) SCH SCU = SFalse + (%==) SCH SCV = SFalse + (%==) SCH SCW = SFalse + (%==) SCH SCX = SFalse + (%==) SCH SCY = SFalse + (%==) SCH SCZ = SFalse + (%==) SCI SCA = SFalse + (%==) SCI SCB = SFalse + (%==) SCI SCC = SFalse + (%==) SCI SCD = SFalse + (%==) SCI SCE = SFalse + (%==) SCI SCF = SFalse + (%==) SCI SCG = SFalse + (%==) SCI SCH = SFalse + (%==) SCI SCI = STrue + (%==) SCI SCJ = SFalse + (%==) SCI SCK = SFalse + (%==) SCI SCL = SFalse + (%==) SCI SCM = SFalse + (%==) SCI SCN = SFalse + (%==) SCI SCO = SFalse + (%==) SCI SCP = SFalse + (%==) SCI SCQ = SFalse + (%==) SCI SCR = SFalse + (%==) SCI SCS = SFalse + (%==) SCI SCT = SFalse + (%==) SCI SCU = SFalse + (%==) SCI SCV = SFalse + (%==) SCI SCW = SFalse + (%==) SCI SCX = SFalse + (%==) SCI SCY = SFalse + (%==) SCI SCZ = SFalse + (%==) SCJ SCA = SFalse + (%==) SCJ SCB = SFalse + (%==) SCJ SCC = SFalse + (%==) SCJ SCD = SFalse + (%==) SCJ SCE = SFalse + (%==) SCJ SCF = SFalse + (%==) SCJ SCG = SFalse + (%==) SCJ SCH = SFalse + (%==) SCJ SCI = SFalse + (%==) SCJ SCJ = STrue + (%==) SCJ SCK = SFalse + (%==) SCJ SCL = SFalse + (%==) SCJ SCM = SFalse + (%==) SCJ SCN = SFalse + (%==) SCJ SCO = SFalse + (%==) SCJ SCP = SFalse + (%==) SCJ SCQ = SFalse + (%==) SCJ SCR = SFalse + (%==) SCJ SCS = SFalse + (%==) SCJ SCT = SFalse + (%==) SCJ SCU = SFalse + (%==) SCJ SCV = SFalse + (%==) SCJ SCW = SFalse + (%==) SCJ SCX = SFalse + (%==) SCJ SCY = SFalse + (%==) SCJ SCZ = SFalse + (%==) SCK SCA = SFalse + (%==) SCK SCB = SFalse + (%==) SCK SCC = SFalse + (%==) SCK SCD = SFalse + (%==) SCK SCE = SFalse + (%==) SCK SCF = SFalse + (%==) SCK SCG = SFalse + (%==) SCK SCH = SFalse + (%==) SCK SCI = SFalse + (%==) SCK SCJ = SFalse + (%==) SCK SCK = STrue + (%==) SCK SCL = SFalse + (%==) SCK SCM = SFalse + (%==) SCK SCN = SFalse + (%==) SCK SCO = SFalse + (%==) SCK SCP = SFalse + (%==) SCK SCQ = SFalse + (%==) SCK SCR = SFalse + (%==) SCK SCS = SFalse + (%==) SCK SCT = SFalse + (%==) SCK SCU = SFalse + (%==) SCK SCV = SFalse + (%==) SCK SCW = SFalse + (%==) SCK SCX = SFalse + (%==) SCK SCY = SFalse + (%==) SCK SCZ = SFalse + (%==) SCL SCA = SFalse + (%==) SCL SCB = SFalse + (%==) SCL SCC = SFalse + (%==) SCL SCD = SFalse + (%==) SCL SCE = SFalse + (%==) SCL SCF = SFalse + (%==) SCL SCG = SFalse + (%==) SCL SCH = SFalse + (%==) SCL SCI = SFalse + (%==) SCL SCJ = SFalse + (%==) SCL SCK = SFalse + (%==) SCL SCL = STrue + (%==) SCL SCM = SFalse + (%==) SCL SCN = SFalse + (%==) SCL SCO = SFalse + (%==) SCL SCP = SFalse + (%==) SCL SCQ = SFalse + (%==) SCL SCR = SFalse + (%==) SCL SCS = SFalse + (%==) SCL SCT = SFalse + (%==) SCL SCU = SFalse + (%==) SCL SCV = SFalse + (%==) SCL SCW = SFalse + (%==) SCL SCX = SFalse + (%==) SCL SCY = SFalse + (%==) SCL SCZ = SFalse + (%==) SCM SCA = SFalse + (%==) SCM SCB = SFalse + (%==) SCM SCC = SFalse + (%==) SCM SCD = SFalse + (%==) SCM SCE = SFalse + (%==) SCM SCF = SFalse + (%==) SCM SCG = SFalse + (%==) SCM SCH = SFalse + (%==) SCM SCI = SFalse + (%==) SCM SCJ = SFalse + (%==) SCM SCK = SFalse + (%==) SCM SCL = SFalse + (%==) SCM SCM = STrue + (%==) SCM SCN = SFalse + (%==) SCM SCO = SFalse + (%==) SCM SCP = SFalse + (%==) SCM SCQ = SFalse + (%==) SCM SCR = SFalse + (%==) SCM SCS = SFalse + (%==) SCM SCT = SFalse + (%==) SCM SCU = SFalse + (%==) SCM SCV = SFalse + (%==) SCM SCW = SFalse + (%==) SCM SCX = SFalse + (%==) SCM SCY = SFalse + (%==) SCM SCZ = SFalse + (%==) SCN SCA = SFalse + (%==) SCN SCB = SFalse + (%==) SCN SCC = SFalse + (%==) SCN SCD = SFalse + (%==) SCN SCE = SFalse + (%==) SCN SCF = SFalse + (%==) SCN SCG = SFalse + (%==) SCN SCH = SFalse + (%==) SCN SCI = SFalse + (%==) SCN SCJ = SFalse + (%==) SCN SCK = SFalse + (%==) SCN SCL = SFalse + (%==) SCN SCM = SFalse + (%==) SCN SCN = STrue + (%==) SCN SCO = SFalse + (%==) SCN SCP = SFalse + (%==) SCN SCQ = SFalse + (%==) SCN SCR = SFalse + (%==) SCN SCS = SFalse + (%==) SCN SCT = SFalse + (%==) SCN SCU = SFalse + (%==) SCN SCV = SFalse + (%==) SCN SCW = SFalse + (%==) SCN SCX = SFalse + (%==) SCN SCY = SFalse + (%==) SCN SCZ = SFalse + (%==) SCO SCA = SFalse + (%==) SCO SCB = SFalse + (%==) SCO SCC = SFalse + (%==) SCO SCD = SFalse + (%==) SCO SCE = SFalse + (%==) SCO SCF = SFalse + (%==) SCO SCG = SFalse + (%==) SCO SCH = SFalse + (%==) SCO SCI = SFalse + (%==) SCO SCJ = SFalse + (%==) SCO SCK = SFalse + (%==) SCO SCL = SFalse + (%==) SCO SCM = SFalse + (%==) SCO SCN = SFalse + (%==) SCO SCO = STrue + (%==) SCO SCP = SFalse + (%==) SCO SCQ = SFalse + (%==) SCO SCR = SFalse + (%==) SCO SCS = SFalse + (%==) SCO SCT = SFalse + (%==) SCO SCU = SFalse + (%==) SCO SCV = SFalse + (%==) SCO SCW = SFalse + (%==) SCO SCX = SFalse + (%==) SCO SCY = SFalse + (%==) SCO SCZ = SFalse + (%==) SCP SCA = SFalse + (%==) SCP SCB = SFalse + (%==) SCP SCC = SFalse + (%==) SCP SCD = SFalse + (%==) SCP SCE = SFalse + (%==) SCP SCF = SFalse + (%==) SCP SCG = SFalse + (%==) SCP SCH = SFalse + (%==) SCP SCI = SFalse + (%==) SCP SCJ = SFalse + (%==) SCP SCK = SFalse + (%==) SCP SCL = SFalse + (%==) SCP SCM = SFalse + (%==) SCP SCN = SFalse + (%==) SCP SCO = SFalse + (%==) SCP SCP = STrue + (%==) SCP SCQ = SFalse + (%==) SCP SCR = SFalse + (%==) SCP SCS = SFalse + (%==) SCP SCT = SFalse + (%==) SCP SCU = SFalse + (%==) SCP SCV = SFalse + (%==) SCP SCW = SFalse + (%==) SCP SCX = SFalse + (%==) SCP SCY = SFalse + (%==) SCP SCZ = SFalse + (%==) SCQ SCA = SFalse + (%==) SCQ SCB = SFalse + (%==) SCQ SCC = SFalse + (%==) SCQ SCD = SFalse + (%==) SCQ SCE = SFalse + (%==) SCQ SCF = SFalse + (%==) SCQ SCG = SFalse + (%==) SCQ SCH = SFalse + (%==) SCQ SCI = SFalse + (%==) SCQ SCJ = SFalse + (%==) SCQ SCK = SFalse + (%==) SCQ SCL = SFalse + (%==) SCQ SCM = SFalse + (%==) SCQ SCN = SFalse + (%==) SCQ SCO = SFalse + (%==) SCQ SCP = SFalse + (%==) SCQ SCQ = STrue + (%==) SCQ SCR = SFalse + (%==) SCQ SCS = SFalse + (%==) SCQ SCT = SFalse + (%==) SCQ SCU = SFalse + (%==) SCQ SCV = SFalse + (%==) SCQ SCW = SFalse + (%==) SCQ SCX = SFalse + (%==) SCQ SCY = SFalse + (%==) SCQ SCZ = SFalse + (%==) SCR SCA = SFalse + (%==) SCR SCB = SFalse + (%==) SCR SCC = SFalse + (%==) SCR SCD = SFalse + (%==) SCR SCE = SFalse + (%==) SCR SCF = SFalse + (%==) SCR SCG = SFalse + (%==) SCR SCH = SFalse + (%==) SCR SCI = SFalse + (%==) SCR SCJ = SFalse + (%==) SCR SCK = SFalse + (%==) SCR SCL = SFalse + (%==) SCR SCM = SFalse + (%==) SCR SCN = SFalse + (%==) SCR SCO = SFalse + (%==) SCR SCP = SFalse + (%==) SCR SCQ = SFalse + (%==) SCR SCR = STrue + (%==) SCR SCS = SFalse + (%==) SCR SCT = SFalse + (%==) SCR SCU = SFalse + (%==) SCR SCV = SFalse + (%==) SCR SCW = SFalse + (%==) SCR SCX = SFalse + (%==) SCR SCY = SFalse + (%==) SCR SCZ = SFalse + (%==) SCS SCA = SFalse + (%==) SCS SCB = SFalse + (%==) SCS SCC = SFalse + (%==) SCS SCD = SFalse + (%==) SCS SCE = SFalse + (%==) SCS SCF = SFalse + (%==) SCS SCG = SFalse + (%==) SCS SCH = SFalse + (%==) SCS SCI = SFalse + (%==) SCS SCJ = SFalse + (%==) SCS SCK = SFalse + (%==) SCS SCL = SFalse + (%==) SCS SCM = SFalse + (%==) SCS SCN = SFalse + (%==) SCS SCO = SFalse + (%==) SCS SCP = SFalse + (%==) SCS SCQ = SFalse + (%==) SCS SCR = SFalse + (%==) SCS SCS = STrue + (%==) SCS SCT = SFalse + (%==) SCS SCU = SFalse + (%==) SCS SCV = SFalse + (%==) SCS SCW = SFalse + (%==) SCS SCX = SFalse + (%==) SCS SCY = SFalse + (%==) SCS SCZ = SFalse + (%==) SCT SCA = SFalse + (%==) SCT SCB = SFalse + (%==) SCT SCC = SFalse + (%==) SCT SCD = SFalse + (%==) SCT SCE = SFalse + (%==) SCT SCF = SFalse + (%==) SCT SCG = SFalse + (%==) SCT SCH = SFalse + (%==) SCT SCI = SFalse + (%==) SCT SCJ = SFalse + (%==) SCT SCK = SFalse + (%==) SCT SCL = SFalse + (%==) SCT SCM = SFalse + (%==) SCT SCN = SFalse + (%==) SCT SCO = SFalse + (%==) SCT SCP = SFalse + (%==) SCT SCQ = SFalse + (%==) SCT SCR = SFalse + (%==) SCT SCS = SFalse + (%==) SCT SCT = STrue + (%==) SCT SCU = SFalse + (%==) SCT SCV = SFalse + (%==) SCT SCW = SFalse + (%==) SCT SCX = SFalse + (%==) SCT SCY = SFalse + (%==) SCT SCZ = SFalse + (%==) SCU SCA = SFalse + (%==) SCU SCB = SFalse + (%==) SCU SCC = SFalse + (%==) SCU SCD = SFalse + (%==) SCU SCE = SFalse + (%==) SCU SCF = SFalse + (%==) SCU SCG = SFalse + (%==) SCU SCH = SFalse + (%==) SCU SCI = SFalse + (%==) SCU SCJ = SFalse + (%==) SCU SCK = SFalse + (%==) SCU SCL = SFalse + (%==) SCU SCM = SFalse + (%==) SCU SCN = SFalse + (%==) SCU SCO = SFalse + (%==) SCU SCP = SFalse + (%==) SCU SCQ = SFalse + (%==) SCU SCR = SFalse + (%==) SCU SCS = SFalse + (%==) SCU SCT = SFalse + (%==) SCU SCU = STrue + (%==) SCU SCV = SFalse + (%==) SCU SCW = SFalse + (%==) SCU SCX = SFalse + (%==) SCU SCY = SFalse + (%==) SCU SCZ = SFalse + (%==) SCV SCA = SFalse + (%==) SCV SCB = SFalse + (%==) SCV SCC = SFalse + (%==) SCV SCD = SFalse + (%==) SCV SCE = SFalse + (%==) SCV SCF = SFalse + (%==) SCV SCG = SFalse + (%==) SCV SCH = SFalse + (%==) SCV SCI = SFalse + (%==) SCV SCJ = SFalse + (%==) SCV SCK = SFalse + (%==) SCV SCL = SFalse + (%==) SCV SCM = SFalse + (%==) SCV SCN = SFalse + (%==) SCV SCO = SFalse + (%==) SCV SCP = SFalse + (%==) SCV SCQ = SFalse + (%==) SCV SCR = SFalse + (%==) SCV SCS = SFalse + (%==) SCV SCT = SFalse + (%==) SCV SCU = SFalse + (%==) SCV SCV = STrue + (%==) SCV SCW = SFalse + (%==) SCV SCX = SFalse + (%==) SCV SCY = SFalse + (%==) SCV SCZ = SFalse + (%==) SCW SCA = SFalse + (%==) SCW SCB = SFalse + (%==) SCW SCC = SFalse + (%==) SCW SCD = SFalse + (%==) SCW SCE = SFalse + (%==) SCW SCF = SFalse + (%==) SCW SCG = SFalse + (%==) SCW SCH = SFalse + (%==) SCW SCI = SFalse + (%==) SCW SCJ = SFalse + (%==) SCW SCK = SFalse + (%==) SCW SCL = SFalse + (%==) SCW SCM = SFalse + (%==) SCW SCN = SFalse + (%==) SCW SCO = SFalse + (%==) SCW SCP = SFalse + (%==) SCW SCQ = SFalse + (%==) SCW SCR = SFalse + (%==) SCW SCS = SFalse + (%==) SCW SCT = SFalse + (%==) SCW SCU = SFalse + (%==) SCW SCV = SFalse + (%==) SCW SCW = STrue + (%==) SCW SCX = SFalse + (%==) SCW SCY = SFalse + (%==) SCW SCZ = SFalse + (%==) SCX SCA = SFalse + (%==) SCX SCB = SFalse + (%==) SCX SCC = SFalse + (%==) SCX SCD = SFalse + (%==) SCX SCE = SFalse + (%==) SCX SCF = SFalse + (%==) SCX SCG = SFalse + (%==) SCX SCH = SFalse + (%==) SCX SCI = SFalse + (%==) SCX SCJ = SFalse + (%==) SCX SCK = SFalse + (%==) SCX SCL = SFalse + (%==) SCX SCM = SFalse + (%==) SCX SCN = SFalse + (%==) SCX SCO = SFalse + (%==) SCX SCP = SFalse + (%==) SCX SCQ = SFalse + (%==) SCX SCR = SFalse + (%==) SCX SCS = SFalse + (%==) SCX SCT = SFalse + (%==) SCX SCU = SFalse + (%==) SCX SCV = SFalse + (%==) SCX SCW = SFalse + (%==) SCX SCX = STrue + (%==) SCX SCY = SFalse + (%==) SCX SCZ = SFalse + (%==) SCY SCA = SFalse + (%==) SCY SCB = SFalse + (%==) SCY SCC = SFalse + (%==) SCY SCD = SFalse + (%==) SCY SCE = SFalse + (%==) SCY SCF = SFalse + (%==) SCY SCG = SFalse + (%==) SCY SCH = SFalse + (%==) SCY SCI = SFalse + (%==) SCY SCJ = SFalse + (%==) SCY SCK = SFalse + (%==) SCY SCL = SFalse + (%==) SCY SCM = SFalse + (%==) SCY SCN = SFalse + (%==) SCY SCO = SFalse + (%==) SCY SCP = SFalse + (%==) SCY SCQ = SFalse + (%==) SCY SCR = SFalse + (%==) SCY SCS = SFalse + (%==) SCY SCT = SFalse + (%==) SCY SCU = SFalse + (%==) SCY SCV = SFalse + (%==) SCY SCW = SFalse + (%==) SCY SCX = SFalse + (%==) SCY SCY = STrue + (%==) SCY SCZ = SFalse + (%==) SCZ SCA = SFalse + (%==) SCZ SCB = SFalse + (%==) SCZ SCC = SFalse + (%==) SCZ SCD = SFalse + (%==) SCZ SCE = SFalse + (%==) SCZ SCF = SFalse + (%==) SCZ SCG = SFalse + (%==) SCZ SCH = SFalse + (%==) SCZ SCI = SFalse + (%==) SCZ SCJ = SFalse + (%==) SCZ SCK = SFalse + (%==) SCZ SCL = SFalse + (%==) SCZ SCM = SFalse + (%==) SCZ SCN = SFalse + (%==) SCZ SCO = SFalse + (%==) SCZ SCP = SFalse + (%==) SCZ SCQ = SFalse + (%==) SCZ SCR = SFalse + (%==) SCZ SCS = SFalse + (%==) SCZ SCT = SFalse + (%==) SCZ SCU = SFalse + (%==) SCZ SCV = SFalse + (%==) SCZ SCW = SFalse + (%==) SCZ SCX = SFalse + (%==) SCZ SCY = SFalse + (%==) SCZ SCZ = STrue + instance (SDecide U, SDecide Nat) => SDecide U where + (%~) SBOOL SBOOL = Proved Refl + (%~) SBOOL SSTRING = Disproved (\case) + (%~) SBOOL SNAT = Disproved (\case) + (%~) SBOOL (SVEC _ _) = Disproved (\case) + (%~) SSTRING SBOOL = Disproved (\case) + (%~) SSTRING SSTRING = Proved Refl + (%~) SSTRING SNAT = Disproved (\case) + (%~) SSTRING (SVEC _ _) = Disproved (\case) + (%~) SNAT SBOOL = Disproved (\case) + (%~) SNAT SSTRING = Disproved (\case) + (%~) SNAT SNAT = Proved Refl + (%~) SNAT (SVEC _ _) = Disproved (\case) + (%~) (SVEC _ _) SBOOL = Disproved (\case) + (%~) (SVEC _ _) SSTRING = Disproved (\case) + (%~) (SVEC _ _) SNAT = Disproved (\case) + (%~) (SVEC a a) (SVEC b b) + = (\cases + (Proved Refl) (Proved Refl) -> Proved Refl + (Disproved contra) _ -> Disproved (\cases Refl -> contra Refl) + _ (Disproved contra) -> Disproved (\cases Refl -> contra Refl)) + ((%~) a b) ((%~) a b) + instance Eq (SU (z :: U)) where + (==) _ _ = True + instance (SDecide U, SDecide Nat) => + GHC.Internal.Data.Type.Equality.TestEquality (SU :: U + -> Type) where + GHC.Internal.Data.Type.Equality.testEquality + = Data.Singletons.Decide.decideEquality + instance (SDecide U, SDecide Nat) => + GHC.Internal.Data.Type.Coercion.TestCoercion (SU :: U + -> Type) where + GHC.Internal.Data.Type.Coercion.testCoercion + = Data.Singletons.Decide.decideCoercion + instance SDecide AChar where + (%~) SCA SCA = Proved Refl + (%~) SCA SCB = Disproved (\case) + (%~) SCA SCC = Disproved (\case) + (%~) SCA SCD = Disproved (\case) + (%~) SCA SCE = Disproved (\case) + (%~) SCA SCF = Disproved (\case) + (%~) SCA SCG = Disproved (\case) + (%~) SCA SCH = Disproved (\case) + (%~) SCA SCI = Disproved (\case) + (%~) SCA SCJ = Disproved (\case) + (%~) SCA SCK = Disproved (\case) + (%~) SCA SCL = Disproved (\case) + (%~) SCA SCM = Disproved (\case) + (%~) SCA SCN = Disproved (\case) + (%~) SCA SCO = Disproved (\case) + (%~) SCA SCP = Disproved (\case) + (%~) SCA SCQ = Disproved (\case) + (%~) SCA SCR = Disproved (\case) + (%~) SCA SCS = Disproved (\case) + (%~) SCA SCT = Disproved (\case) + (%~) SCA SCU = Disproved (\case) + (%~) SCA SCV = Disproved (\case) + (%~) SCA SCW = Disproved (\case) + (%~) SCA SCX = Disproved (\case) + (%~) SCA SCY = Disproved (\case) + (%~) SCA SCZ = Disproved (\case) + (%~) SCB SCA = Disproved (\case) + (%~) SCB SCB = Proved Refl + (%~) SCB SCC = Disproved (\case) + (%~) SCB SCD = Disproved (\case) + (%~) SCB SCE = Disproved (\case) + (%~) SCB SCF = Disproved (\case) + (%~) SCB SCG = Disproved (\case) + (%~) SCB SCH = Disproved (\case) + (%~) SCB SCI = Disproved (\case) + (%~) SCB SCJ = Disproved (\case) + (%~) SCB SCK = Disproved (\case) + (%~) SCB SCL = Disproved (\case) + (%~) SCB SCM = Disproved (\case) + (%~) SCB SCN = Disproved (\case) + (%~) SCB SCO = Disproved (\case) + (%~) SCB SCP = Disproved (\case) + (%~) SCB SCQ = Disproved (\case) + (%~) SCB SCR = Disproved (\case) + (%~) SCB SCS = Disproved (\case) + (%~) SCB SCT = Disproved (\case) + (%~) SCB SCU = Disproved (\case) + (%~) SCB SCV = Disproved (\case) + (%~) SCB SCW = Disproved (\case) + (%~) SCB SCX = Disproved (\case) + (%~) SCB SCY = Disproved (\case) + (%~) SCB SCZ = Disproved (\case) + (%~) SCC SCA = Disproved (\case) + (%~) SCC SCB = Disproved (\case) + (%~) SCC SCC = Proved Refl + (%~) SCC SCD = Disproved (\case) + (%~) SCC SCE = Disproved (\case) + (%~) SCC SCF = Disproved (\case) + (%~) SCC SCG = Disproved (\case) + (%~) SCC SCH = Disproved (\case) + (%~) SCC SCI = Disproved (\case) + (%~) SCC SCJ = Disproved (\case) + (%~) SCC SCK = Disproved (\case) + (%~) SCC SCL = Disproved (\case) + (%~) SCC SCM = Disproved (\case) + (%~) SCC SCN = Disproved (\case) + (%~) SCC SCO = Disproved (\case) + (%~) SCC SCP = Disproved (\case) + (%~) SCC SCQ = Disproved (\case) + (%~) SCC SCR = Disproved (\case) + (%~) SCC SCS = Disproved (\case) + (%~) SCC SCT = Disproved (\case) + (%~) SCC SCU = Disproved (\case) + (%~) SCC SCV = Disproved (\case) + (%~) SCC SCW = Disproved (\case) + (%~) SCC SCX = Disproved (\case) + (%~) SCC SCY = Disproved (\case) + (%~) SCC SCZ = Disproved (\case) + (%~) SCD SCA = Disproved (\case) + (%~) SCD SCB = Disproved (\case) + (%~) SCD SCC = Disproved (\case) + (%~) SCD SCD = Proved Refl + (%~) SCD SCE = Disproved (\case) + (%~) SCD SCF = Disproved (\case) + (%~) SCD SCG = Disproved (\case) + (%~) SCD SCH = Disproved (\case) + (%~) SCD SCI = Disproved (\case) + (%~) SCD SCJ = Disproved (\case) + (%~) SCD SCK = Disproved (\case) + (%~) SCD SCL = Disproved (\case) + (%~) SCD SCM = Disproved (\case) + (%~) SCD SCN = Disproved (\case) + (%~) SCD SCO = Disproved (\case) + (%~) SCD SCP = Disproved (\case) + (%~) SCD SCQ = Disproved (\case) + (%~) SCD SCR = Disproved (\case) + (%~) SCD SCS = Disproved (\case) + (%~) SCD SCT = Disproved (\case) + (%~) SCD SCU = Disproved (\case) + (%~) SCD SCV = Disproved (\case) + (%~) SCD SCW = Disproved (\case) + (%~) SCD SCX = Disproved (\case) + (%~) SCD SCY = Disproved (\case) + (%~) SCD SCZ = Disproved (\case) + (%~) SCE SCA = Disproved (\case) + (%~) SCE SCB = Disproved (\case) + (%~) SCE SCC = Disproved (\case) + (%~) SCE SCD = Disproved (\case) + (%~) SCE SCE = Proved Refl + (%~) SCE SCF = Disproved (\case) + (%~) SCE SCG = Disproved (\case) + (%~) SCE SCH = Disproved (\case) + (%~) SCE SCI = Disproved (\case) + (%~) SCE SCJ = Disproved (\case) + (%~) SCE SCK = Disproved (\case) + (%~) SCE SCL = Disproved (\case) + (%~) SCE SCM = Disproved (\case) + (%~) SCE SCN = Disproved (\case) + (%~) SCE SCO = Disproved (\case) + (%~) SCE SCP = Disproved (\case) + (%~) SCE SCQ = Disproved (\case) + (%~) SCE SCR = Disproved (\case) + (%~) SCE SCS = Disproved (\case) + (%~) SCE SCT = Disproved (\case) + (%~) SCE SCU = Disproved (\case) + (%~) SCE SCV = Disproved (\case) + (%~) SCE SCW = Disproved (\case) + (%~) SCE SCX = Disproved (\case) + (%~) SCE SCY = Disproved (\case) + (%~) SCE SCZ = Disproved (\case) + (%~) SCF SCA = Disproved (\case) + (%~) SCF SCB = Disproved (\case) + (%~) SCF SCC = Disproved (\case) + (%~) SCF SCD = Disproved (\case) + (%~) SCF SCE = Disproved (\case) + (%~) SCF SCF = Proved Refl + (%~) SCF SCG = Disproved (\case) + (%~) SCF SCH = Disproved (\case) + (%~) SCF SCI = Disproved (\case) + (%~) SCF SCJ = Disproved (\case) + (%~) SCF SCK = Disproved (\case) + (%~) SCF SCL = Disproved (\case) + (%~) SCF SCM = Disproved (\case) + (%~) SCF SCN = Disproved (\case) + (%~) SCF SCO = Disproved (\case) + (%~) SCF SCP = Disproved (\case) + (%~) SCF SCQ = Disproved (\case) + (%~) SCF SCR = Disproved (\case) + (%~) SCF SCS = Disproved (\case) + (%~) SCF SCT = Disproved (\case) + (%~) SCF SCU = Disproved (\case) + (%~) SCF SCV = Disproved (\case) + (%~) SCF SCW = Disproved (\case) + (%~) SCF SCX = Disproved (\case) + (%~) SCF SCY = Disproved (\case) + (%~) SCF SCZ = Disproved (\case) + (%~) SCG SCA = Disproved (\case) + (%~) SCG SCB = Disproved (\case) + (%~) SCG SCC = Disproved (\case) + (%~) SCG SCD = Disproved (\case) + (%~) SCG SCE = Disproved (\case) + (%~) SCG SCF = Disproved (\case) + (%~) SCG SCG = Proved Refl + (%~) SCG SCH = Disproved (\case) + (%~) SCG SCI = Disproved (\case) + (%~) SCG SCJ = Disproved (\case) + (%~) SCG SCK = Disproved (\case) + (%~) SCG SCL = Disproved (\case) + (%~) SCG SCM = Disproved (\case) + (%~) SCG SCN = Disproved (\case) + (%~) SCG SCO = Disproved (\case) + (%~) SCG SCP = Disproved (\case) + (%~) SCG SCQ = Disproved (\case) + (%~) SCG SCR = Disproved (\case) + (%~) SCG SCS = Disproved (\case) + (%~) SCG SCT = Disproved (\case) + (%~) SCG SCU = Disproved (\case) + (%~) SCG SCV = Disproved (\case) + (%~) SCG SCW = Disproved (\case) + (%~) SCG SCX = Disproved (\case) + (%~) SCG SCY = Disproved (\case) + (%~) SCG SCZ = Disproved (\case) + (%~) SCH SCA = Disproved (\case) + (%~) SCH SCB = Disproved (\case) + (%~) SCH SCC = Disproved (\case) + (%~) SCH SCD = Disproved (\case) + (%~) SCH SCE = Disproved (\case) + (%~) SCH SCF = Disproved (\case) + (%~) SCH SCG = Disproved (\case) + (%~) SCH SCH = Proved Refl + (%~) SCH SCI = Disproved (\case) + (%~) SCH SCJ = Disproved (\case) + (%~) SCH SCK = Disproved (\case) + (%~) SCH SCL = Disproved (\case) + (%~) SCH SCM = Disproved (\case) + (%~) SCH SCN = Disproved (\case) + (%~) SCH SCO = Disproved (\case) + (%~) SCH SCP = Disproved (\case) + (%~) SCH SCQ = Disproved (\case) + (%~) SCH SCR = Disproved (\case) + (%~) SCH SCS = Disproved (\case) + (%~) SCH SCT = Disproved (\case) + (%~) SCH SCU = Disproved (\case) + (%~) SCH SCV = Disproved (\case) + (%~) SCH SCW = Disproved (\case) + (%~) SCH SCX = Disproved (\case) + (%~) SCH SCY = Disproved (\case) + (%~) SCH SCZ = Disproved (\case) + (%~) SCI SCA = Disproved (\case) + (%~) SCI SCB = Disproved (\case) + (%~) SCI SCC = Disproved (\case) + (%~) SCI SCD = Disproved (\case) + (%~) SCI SCE = Disproved (\case) + (%~) SCI SCF = Disproved (\case) + (%~) SCI SCG = Disproved (\case) + (%~) SCI SCH = Disproved (\case) + (%~) SCI SCI = Proved Refl + (%~) SCI SCJ = Disproved (\case) + (%~) SCI SCK = Disproved (\case) + (%~) SCI SCL = Disproved (\case) + (%~) SCI SCM = Disproved (\case) + (%~) SCI SCN = Disproved (\case) + (%~) SCI SCO = Disproved (\case) + (%~) SCI SCP = Disproved (\case) + (%~) SCI SCQ = Disproved (\case) + (%~) SCI SCR = Disproved (\case) + (%~) SCI SCS = Disproved (\case) + (%~) SCI SCT = Disproved (\case) + (%~) SCI SCU = Disproved (\case) + (%~) SCI SCV = Disproved (\case) + (%~) SCI SCW = Disproved (\case) + (%~) SCI SCX = Disproved (\case) + (%~) SCI SCY = Disproved (\case) + (%~) SCI SCZ = Disproved (\case) + (%~) SCJ SCA = Disproved (\case) + (%~) SCJ SCB = Disproved (\case) + (%~) SCJ SCC = Disproved (\case) + (%~) SCJ SCD = Disproved (\case) + (%~) SCJ SCE = Disproved (\case) + (%~) SCJ SCF = Disproved (\case) + (%~) SCJ SCG = Disproved (\case) + (%~) SCJ SCH = Disproved (\case) + (%~) SCJ SCI = Disproved (\case) + (%~) SCJ SCJ = Proved Refl + (%~) SCJ SCK = Disproved (\case) + (%~) SCJ SCL = Disproved (\case) + (%~) SCJ SCM = Disproved (\case) + (%~) SCJ SCN = Disproved (\case) + (%~) SCJ SCO = Disproved (\case) + (%~) SCJ SCP = Disproved (\case) + (%~) SCJ SCQ = Disproved (\case) + (%~) SCJ SCR = Disproved (\case) + (%~) SCJ SCS = Disproved (\case) + (%~) SCJ SCT = Disproved (\case) + (%~) SCJ SCU = Disproved (\case) + (%~) SCJ SCV = Disproved (\case) + (%~) SCJ SCW = Disproved (\case) + (%~) SCJ SCX = Disproved (\case) + (%~) SCJ SCY = Disproved (\case) + (%~) SCJ SCZ = Disproved (\case) + (%~) SCK SCA = Disproved (\case) + (%~) SCK SCB = Disproved (\case) + (%~) SCK SCC = Disproved (\case) + (%~) SCK SCD = Disproved (\case) + (%~) SCK SCE = Disproved (\case) + (%~) SCK SCF = Disproved (\case) + (%~) SCK SCG = Disproved (\case) + (%~) SCK SCH = Disproved (\case) + (%~) SCK SCI = Disproved (\case) + (%~) SCK SCJ = Disproved (\case) + (%~) SCK SCK = Proved Refl + (%~) SCK SCL = Disproved (\case) + (%~) SCK SCM = Disproved (\case) + (%~) SCK SCN = Disproved (\case) + (%~) SCK SCO = Disproved (\case) + (%~) SCK SCP = Disproved (\case) + (%~) SCK SCQ = Disproved (\case) + (%~) SCK SCR = Disproved (\case) + (%~) SCK SCS = Disproved (\case) + (%~) SCK SCT = Disproved (\case) + (%~) SCK SCU = Disproved (\case) + (%~) SCK SCV = Disproved (\case) + (%~) SCK SCW = Disproved (\case) + (%~) SCK SCX = Disproved (\case) + (%~) SCK SCY = Disproved (\case) + (%~) SCK SCZ = Disproved (\case) + (%~) SCL SCA = Disproved (\case) + (%~) SCL SCB = Disproved (\case) + (%~) SCL SCC = Disproved (\case) + (%~) SCL SCD = Disproved (\case) + (%~) SCL SCE = Disproved (\case) + (%~) SCL SCF = Disproved (\case) + (%~) SCL SCG = Disproved (\case) + (%~) SCL SCH = Disproved (\case) + (%~) SCL SCI = Disproved (\case) + (%~) SCL SCJ = Disproved (\case) + (%~) SCL SCK = Disproved (\case) + (%~) SCL SCL = Proved Refl + (%~) SCL SCM = Disproved (\case) + (%~) SCL SCN = Disproved (\case) + (%~) SCL SCO = Disproved (\case) + (%~) SCL SCP = Disproved (\case) + (%~) SCL SCQ = Disproved (\case) + (%~) SCL SCR = Disproved (\case) + (%~) SCL SCS = Disproved (\case) + (%~) SCL SCT = Disproved (\case) + (%~) SCL SCU = Disproved (\case) + (%~) SCL SCV = Disproved (\case) + (%~) SCL SCW = Disproved (\case) + (%~) SCL SCX = Disproved (\case) + (%~) SCL SCY = Disproved (\case) + (%~) SCL SCZ = Disproved (\case) + (%~) SCM SCA = Disproved (\case) + (%~) SCM SCB = Disproved (\case) + (%~) SCM SCC = Disproved (\case) + (%~) SCM SCD = Disproved (\case) + (%~) SCM SCE = Disproved (\case) + (%~) SCM SCF = Disproved (\case) + (%~) SCM SCG = Disproved (\case) + (%~) SCM SCH = Disproved (\case) + (%~) SCM SCI = Disproved (\case) + (%~) SCM SCJ = Disproved (\case) + (%~) SCM SCK = Disproved (\case) + (%~) SCM SCL = Disproved (\case) + (%~) SCM SCM = Proved Refl + (%~) SCM SCN = Disproved (\case) + (%~) SCM SCO = Disproved (\case) + (%~) SCM SCP = Disproved (\case) + (%~) SCM SCQ = Disproved (\case) + (%~) SCM SCR = Disproved (\case) + (%~) SCM SCS = Disproved (\case) + (%~) SCM SCT = Disproved (\case) + (%~) SCM SCU = Disproved (\case) + (%~) SCM SCV = Disproved (\case) + (%~) SCM SCW = Disproved (\case) + (%~) SCM SCX = Disproved (\case) + (%~) SCM SCY = Disproved (\case) + (%~) SCM SCZ = Disproved (\case) + (%~) SCN SCA = Disproved (\case) + (%~) SCN SCB = Disproved (\case) + (%~) SCN SCC = Disproved (\case) + (%~) SCN SCD = Disproved (\case) + (%~) SCN SCE = Disproved (\case) + (%~) SCN SCF = Disproved (\case) + (%~) SCN SCG = Disproved (\case) + (%~) SCN SCH = Disproved (\case) + (%~) SCN SCI = Disproved (\case) + (%~) SCN SCJ = Disproved (\case) + (%~) SCN SCK = Disproved (\case) + (%~) SCN SCL = Disproved (\case) + (%~) SCN SCM = Disproved (\case) + (%~) SCN SCN = Proved Refl + (%~) SCN SCO = Disproved (\case) + (%~) SCN SCP = Disproved (\case) + (%~) SCN SCQ = Disproved (\case) + (%~) SCN SCR = Disproved (\case) + (%~) SCN SCS = Disproved (\case) + (%~) SCN SCT = Disproved (\case) + (%~) SCN SCU = Disproved (\case) + (%~) SCN SCV = Disproved (\case) + (%~) SCN SCW = Disproved (\case) + (%~) SCN SCX = Disproved (\case) + (%~) SCN SCY = Disproved (\case) + (%~) SCN SCZ = Disproved (\case) + (%~) SCO SCA = Disproved (\case) + (%~) SCO SCB = Disproved (\case) + (%~) SCO SCC = Disproved (\case) + (%~) SCO SCD = Disproved (\case) + (%~) SCO SCE = Disproved (\case) + (%~) SCO SCF = Disproved (\case) + (%~) SCO SCG = Disproved (\case) + (%~) SCO SCH = Disproved (\case) + (%~) SCO SCI = Disproved (\case) + (%~) SCO SCJ = Disproved (\case) + (%~) SCO SCK = Disproved (\case) + (%~) SCO SCL = Disproved (\case) + (%~) SCO SCM = Disproved (\case) + (%~) SCO SCN = Disproved (\case) + (%~) SCO SCO = Proved Refl + (%~) SCO SCP = Disproved (\case) + (%~) SCO SCQ = Disproved (\case) + (%~) SCO SCR = Disproved (\case) + (%~) SCO SCS = Disproved (\case) + (%~) SCO SCT = Disproved (\case) + (%~) SCO SCU = Disproved (\case) + (%~) SCO SCV = Disproved (\case) + (%~) SCO SCW = Disproved (\case) + (%~) SCO SCX = Disproved (\case) + (%~) SCO SCY = Disproved (\case) + (%~) SCO SCZ = Disproved (\case) + (%~) SCP SCA = Disproved (\case) + (%~) SCP SCB = Disproved (\case) + (%~) SCP SCC = Disproved (\case) + (%~) SCP SCD = Disproved (\case) + (%~) SCP SCE = Disproved (\case) + (%~) SCP SCF = Disproved (\case) + (%~) SCP SCG = Disproved (\case) + (%~) SCP SCH = Disproved (\case) + (%~) SCP SCI = Disproved (\case) + (%~) SCP SCJ = Disproved (\case) + (%~) SCP SCK = Disproved (\case) + (%~) SCP SCL = Disproved (\case) + (%~) SCP SCM = Disproved (\case) + (%~) SCP SCN = Disproved (\case) + (%~) SCP SCO = Disproved (\case) + (%~) SCP SCP = Proved Refl + (%~) SCP SCQ = Disproved (\case) + (%~) SCP SCR = Disproved (\case) + (%~) SCP SCS = Disproved (\case) + (%~) SCP SCT = Disproved (\case) + (%~) SCP SCU = Disproved (\case) + (%~) SCP SCV = Disproved (\case) + (%~) SCP SCW = Disproved (\case) + (%~) SCP SCX = Disproved (\case) + (%~) SCP SCY = Disproved (\case) + (%~) SCP SCZ = Disproved (\case) + (%~) SCQ SCA = Disproved (\case) + (%~) SCQ SCB = Disproved (\case) + (%~) SCQ SCC = Disproved (\case) + (%~) SCQ SCD = Disproved (\case) + (%~) SCQ SCE = Disproved (\case) + (%~) SCQ SCF = Disproved (\case) + (%~) SCQ SCG = Disproved (\case) + (%~) SCQ SCH = Disproved (\case) + (%~) SCQ SCI = Disproved (\case) + (%~) SCQ SCJ = Disproved (\case) + (%~) SCQ SCK = Disproved (\case) + (%~) SCQ SCL = Disproved (\case) + (%~) SCQ SCM = Disproved (\case) + (%~) SCQ SCN = Disproved (\case) + (%~) SCQ SCO = Disproved (\case) + (%~) SCQ SCP = Disproved (\case) + (%~) SCQ SCQ = Proved Refl + (%~) SCQ SCR = Disproved (\case) + (%~) SCQ SCS = Disproved (\case) + (%~) SCQ SCT = Disproved (\case) + (%~) SCQ SCU = Disproved (\case) + (%~) SCQ SCV = Disproved (\case) + (%~) SCQ SCW = Disproved (\case) + (%~) SCQ SCX = Disproved (\case) + (%~) SCQ SCY = Disproved (\case) + (%~) SCQ SCZ = Disproved (\case) + (%~) SCR SCA = Disproved (\case) + (%~) SCR SCB = Disproved (\case) + (%~) SCR SCC = Disproved (\case) + (%~) SCR SCD = Disproved (\case) + (%~) SCR SCE = Disproved (\case) + (%~) SCR SCF = Disproved (\case) + (%~) SCR SCG = Disproved (\case) + (%~) SCR SCH = Disproved (\case) + (%~) SCR SCI = Disproved (\case) + (%~) SCR SCJ = Disproved (\case) + (%~) SCR SCK = Disproved (\case) + (%~) SCR SCL = Disproved (\case) + (%~) SCR SCM = Disproved (\case) + (%~) SCR SCN = Disproved (\case) + (%~) SCR SCO = Disproved (\case) + (%~) SCR SCP = Disproved (\case) + (%~) SCR SCQ = Disproved (\case) + (%~) SCR SCR = Proved Refl + (%~) SCR SCS = Disproved (\case) + (%~) SCR SCT = Disproved (\case) + (%~) SCR SCU = Disproved (\case) + (%~) SCR SCV = Disproved (\case) + (%~) SCR SCW = Disproved (\case) + (%~) SCR SCX = Disproved (\case) + (%~) SCR SCY = Disproved (\case) + (%~) SCR SCZ = Disproved (\case) + (%~) SCS SCA = Disproved (\case) + (%~) SCS SCB = Disproved (\case) + (%~) SCS SCC = Disproved (\case) + (%~) SCS SCD = Disproved (\case) + (%~) SCS SCE = Disproved (\case) + (%~) SCS SCF = Disproved (\case) + (%~) SCS SCG = Disproved (\case) + (%~) SCS SCH = Disproved (\case) + (%~) SCS SCI = Disproved (\case) + (%~) SCS SCJ = Disproved (\case) + (%~) SCS SCK = Disproved (\case) + (%~) SCS SCL = Disproved (\case) + (%~) SCS SCM = Disproved (\case) + (%~) SCS SCN = Disproved (\case) + (%~) SCS SCO = Disproved (\case) + (%~) SCS SCP = Disproved (\case) + (%~) SCS SCQ = Disproved (\case) + (%~) SCS SCR = Disproved (\case) + (%~) SCS SCS = Proved Refl + (%~) SCS SCT = Disproved (\case) + (%~) SCS SCU = Disproved (\case) + (%~) SCS SCV = Disproved (\case) + (%~) SCS SCW = Disproved (\case) + (%~) SCS SCX = Disproved (\case) + (%~) SCS SCY = Disproved (\case) + (%~) SCS SCZ = Disproved (\case) + (%~) SCT SCA = Disproved (\case) + (%~) SCT SCB = Disproved (\case) + (%~) SCT SCC = Disproved (\case) + (%~) SCT SCD = Disproved (\case) + (%~) SCT SCE = Disproved (\case) + (%~) SCT SCF = Disproved (\case) + (%~) SCT SCG = Disproved (\case) + (%~) SCT SCH = Disproved (\case) + (%~) SCT SCI = Disproved (\case) + (%~) SCT SCJ = Disproved (\case) + (%~) SCT SCK = Disproved (\case) + (%~) SCT SCL = Disproved (\case) + (%~) SCT SCM = Disproved (\case) + (%~) SCT SCN = Disproved (\case) + (%~) SCT SCO = Disproved (\case) + (%~) SCT SCP = Disproved (\case) + (%~) SCT SCQ = Disproved (\case) + (%~) SCT SCR = Disproved (\case) + (%~) SCT SCS = Disproved (\case) + (%~) SCT SCT = Proved Refl + (%~) SCT SCU = Disproved (\case) + (%~) SCT SCV = Disproved (\case) + (%~) SCT SCW = Disproved (\case) + (%~) SCT SCX = Disproved (\case) + (%~) SCT SCY = Disproved (\case) + (%~) SCT SCZ = Disproved (\case) + (%~) SCU SCA = Disproved (\case) + (%~) SCU SCB = Disproved (\case) + (%~) SCU SCC = Disproved (\case) + (%~) SCU SCD = Disproved (\case) + (%~) SCU SCE = Disproved (\case) + (%~) SCU SCF = Disproved (\case) + (%~) SCU SCG = Disproved (\case) + (%~) SCU SCH = Disproved (\case) + (%~) SCU SCI = Disproved (\case) + (%~) SCU SCJ = Disproved (\case) + (%~) SCU SCK = Disproved (\case) + (%~) SCU SCL = Disproved (\case) + (%~) SCU SCM = Disproved (\case) + (%~) SCU SCN = Disproved (\case) + (%~) SCU SCO = Disproved (\case) + (%~) SCU SCP = Disproved (\case) + (%~) SCU SCQ = Disproved (\case) + (%~) SCU SCR = Disproved (\case) + (%~) SCU SCS = Disproved (\case) + (%~) SCU SCT = Disproved (\case) + (%~) SCU SCU = Proved Refl + (%~) SCU SCV = Disproved (\case) + (%~) SCU SCW = Disproved (\case) + (%~) SCU SCX = Disproved (\case) + (%~) SCU SCY = Disproved (\case) + (%~) SCU SCZ = Disproved (\case) + (%~) SCV SCA = Disproved (\case) + (%~) SCV SCB = Disproved (\case) + (%~) SCV SCC = Disproved (\case) + (%~) SCV SCD = Disproved (\case) + (%~) SCV SCE = Disproved (\case) + (%~) SCV SCF = Disproved (\case) + (%~) SCV SCG = Disproved (\case) + (%~) SCV SCH = Disproved (\case) + (%~) SCV SCI = Disproved (\case) + (%~) SCV SCJ = Disproved (\case) + (%~) SCV SCK = Disproved (\case) + (%~) SCV SCL = Disproved (\case) + (%~) SCV SCM = Disproved (\case) + (%~) SCV SCN = Disproved (\case) + (%~) SCV SCO = Disproved (\case) + (%~) SCV SCP = Disproved (\case) + (%~) SCV SCQ = Disproved (\case) + (%~) SCV SCR = Disproved (\case) + (%~) SCV SCS = Disproved (\case) + (%~) SCV SCT = Disproved (\case) + (%~) SCV SCU = Disproved (\case) + (%~) SCV SCV = Proved Refl + (%~) SCV SCW = Disproved (\case) + (%~) SCV SCX = Disproved (\case) + (%~) SCV SCY = Disproved (\case) + (%~) SCV SCZ = Disproved (\case) + (%~) SCW SCA = Disproved (\case) + (%~) SCW SCB = Disproved (\case) + (%~) SCW SCC = Disproved (\case) + (%~) SCW SCD = Disproved (\case) + (%~) SCW SCE = Disproved (\case) + (%~) SCW SCF = Disproved (\case) + (%~) SCW SCG = Disproved (\case) + (%~) SCW SCH = Disproved (\case) + (%~) SCW SCI = Disproved (\case) + (%~) SCW SCJ = Disproved (\case) + (%~) SCW SCK = Disproved (\case) + (%~) SCW SCL = Disproved (\case) + (%~) SCW SCM = Disproved (\case) + (%~) SCW SCN = Disproved (\case) + (%~) SCW SCO = Disproved (\case) + (%~) SCW SCP = Disproved (\case) + (%~) SCW SCQ = Disproved (\case) + (%~) SCW SCR = Disproved (\case) + (%~) SCW SCS = Disproved (\case) + (%~) SCW SCT = Disproved (\case) + (%~) SCW SCU = Disproved (\case) + (%~) SCW SCV = Disproved (\case) + (%~) SCW SCW = Proved Refl + (%~) SCW SCX = Disproved (\case) + (%~) SCW SCY = Disproved (\case) + (%~) SCW SCZ = Disproved (\case) + (%~) SCX SCA = Disproved (\case) + (%~) SCX SCB = Disproved (\case) + (%~) SCX SCC = Disproved (\case) + (%~) SCX SCD = Disproved (\case) + (%~) SCX SCE = Disproved (\case) + (%~) SCX SCF = Disproved (\case) + (%~) SCX SCG = Disproved (\case) + (%~) SCX SCH = Disproved (\case) + (%~) SCX SCI = Disproved (\case) + (%~) SCX SCJ = Disproved (\case) + (%~) SCX SCK = Disproved (\case) + (%~) SCX SCL = Disproved (\case) + (%~) SCX SCM = Disproved (\case) + (%~) SCX SCN = Disproved (\case) + (%~) SCX SCO = Disproved (\case) + (%~) SCX SCP = Disproved (\case) + (%~) SCX SCQ = Disproved (\case) + (%~) SCX SCR = Disproved (\case) + (%~) SCX SCS = Disproved (\case) + (%~) SCX SCT = Disproved (\case) + (%~) SCX SCU = Disproved (\case) + (%~) SCX SCV = Disproved (\case) + (%~) SCX SCW = Disproved (\case) + (%~) SCX SCX = Proved Refl + (%~) SCX SCY = Disproved (\case) + (%~) SCX SCZ = Disproved (\case) + (%~) SCY SCA = Disproved (\case) + (%~) SCY SCB = Disproved (\case) + (%~) SCY SCC = Disproved (\case) + (%~) SCY SCD = Disproved (\case) + (%~) SCY SCE = Disproved (\case) + (%~) SCY SCF = Disproved (\case) + (%~) SCY SCG = Disproved (\case) + (%~) SCY SCH = Disproved (\case) + (%~) SCY SCI = Disproved (\case) + (%~) SCY SCJ = Disproved (\case) + (%~) SCY SCK = Disproved (\case) + (%~) SCY SCL = Disproved (\case) + (%~) SCY SCM = Disproved (\case) + (%~) SCY SCN = Disproved (\case) + (%~) SCY SCO = Disproved (\case) + (%~) SCY SCP = Disproved (\case) + (%~) SCY SCQ = Disproved (\case) + (%~) SCY SCR = Disproved (\case) + (%~) SCY SCS = Disproved (\case) + (%~) SCY SCT = Disproved (\case) + (%~) SCY SCU = Disproved (\case) + (%~) SCY SCV = Disproved (\case) + (%~) SCY SCW = Disproved (\case) + (%~) SCY SCX = Disproved (\case) + (%~) SCY SCY = Proved Refl + (%~) SCY SCZ = Disproved (\case) + (%~) SCZ SCA = Disproved (\case) + (%~) SCZ SCB = Disproved (\case) + (%~) SCZ SCC = Disproved (\case) + (%~) SCZ SCD = Disproved (\case) + (%~) SCZ SCE = Disproved (\case) + (%~) SCZ SCF = Disproved (\case) + (%~) SCZ SCG = Disproved (\case) + (%~) SCZ SCH = Disproved (\case) + (%~) SCZ SCI = Disproved (\case) + (%~) SCZ SCJ = Disproved (\case) + (%~) SCZ SCK = Disproved (\case) + (%~) SCZ SCL = Disproved (\case) + (%~) SCZ SCM = Disproved (\case) + (%~) SCZ SCN = Disproved (\case) + (%~) SCZ SCO = Disproved (\case) + (%~) SCZ SCP = Disproved (\case) + (%~) SCZ SCQ = Disproved (\case) + (%~) SCZ SCR = Disproved (\case) + (%~) SCZ SCS = Disproved (\case) + (%~) SCZ SCT = Disproved (\case) + (%~) SCZ SCU = Disproved (\case) + (%~) SCZ SCV = Disproved (\case) + (%~) SCZ SCW = Disproved (\case) + (%~) SCZ SCX = Disproved (\case) + (%~) SCZ SCY = Disproved (\case) + (%~) SCZ SCZ = Proved Refl + instance Eq (SAChar (z :: AChar)) where + (==) _ _ = True + instance GHC.Internal.Data.Type.Equality.TestEquality (SAChar :: AChar + -> Type) where + GHC.Internal.Data.Type.Equality.testEquality + = Data.Singletons.Decide.decideEquality + instance GHC.Internal.Data.Type.Coercion.TestCoercion (SAChar :: AChar + -> Type) where + GHC.Internal.Data.Type.Coercion.testCoercion + = Data.Singletons.Decide.decideCoercion + deriving instance (Data.Singletons.ShowSing.ShowSing U, + Data.Singletons.ShowSing.ShowSing Nat) => + Show (SU (z :: U)) + deriving instance Show (SAChar (z :: AChar)) + instance SingI BOOL where + sing = SBOOL + instance SingI STRING where + sing = SSTRING + instance SingI NAT where + sing = SNAT + instance (SingI n, SingI n) => + SingI (VEC (n :: U) (n :: Nat)) where + sing = SVEC sing sing + instance SingI n => SingI1 (VEC (n :: U)) where + liftSing = SVEC sing + instance SingI2 VEC where + liftSing2 = SVEC + instance SingI (VECSym0 :: (~>) U ((~>) Nat U)) where + sing = singFun2 @VECSym0 SVEC + instance SingI d => SingI (VECSym1 (d :: U) :: (~>) Nat U) where + sing = singFun1 @(VECSym1 (d :: U)) (SVEC (sing @d)) + instance SingI1 (VECSym1 :: U -> (~>) Nat U) where + liftSing (s :: Sing (d :: U)) + = singFun1 @(VECSym1 (d :: U)) (SVEC s) + instance SingI CA where + sing = SCA + instance SingI CB where + sing = SCB + instance SingI CC where + sing = SCC + instance SingI CD where + sing = SCD + instance SingI CE where + sing = SCE + instance SingI CF where + sing = SCF + instance SingI CG where + sing = SCG + instance SingI CH where + sing = SCH + instance SingI CI where + sing = SCI + instance SingI CJ where + sing = SCJ + instance SingI CK where + sing = SCK + instance SingI CL where + sing = SCL + instance SingI CM where + sing = SCM + instance SingI CN where + sing = SCN + instance SingI CO where + sing = SCO + instance SingI CP where + sing = SCP + instance SingI CQ where + sing = SCQ + instance SingI CR where + sing = SCR + instance SingI CS where + sing = SCS + instance SingI CT where + sing = SCT + instance SingI CU where + sing = SCU + instance SingI CV where + sing = SCV + instance SingI CW where + sing = SCW + instance SingI CX where + sing = SCX + instance SingI CY where + sing = SCY + instance SingI CZ where + sing = SCZ + instance (SingI n, SingI n) => + SingI (Attr (n :: [AChar]) (n :: U)) where + sing = SAttr sing sing + instance SingI n => SingI1 (Attr (n :: [AChar])) where + liftSing = SAttr sing + instance SingI2 Attr where + liftSing2 = SAttr + instance SingI (AttrSym0 :: (~>) [AChar] ((~>) U Attribute)) where + sing = singFun2 @AttrSym0 SAttr + instance SingI d => + SingI (AttrSym1 (d :: [AChar]) :: (~>) U Attribute) where + sing = singFun1 @(AttrSym1 (d :: [AChar])) (SAttr (sing @d)) + instance SingI1 (AttrSym1 :: [AChar] -> (~>) U Attribute) where + liftSing (s :: Sing (d :: [AChar])) + = singFun1 @(AttrSym1 (d :: [AChar])) (SAttr s) + instance SingI n => SingI (Sch (n :: [Attribute])) where + sing = SSch sing + instance SingI1 Sch where + liftSing = SSch + instance SingI (SchSym0 :: (~>) [Attribute] Schema) where + sing = singFun1 @SchSym0 SSch +GradingClient/Database.hs:0:0:: Splicing declarations + return [] ======> +GradingClient/Database.hs:(0,0)-(0,0): Splicing expression + cases ''Row [| r |] [| changeId (n ++ (getId r)) r |] + ======> + (\cases + (EmptyRow _) -> changeId ((++) n (getId r)) r + (ConsRow _ _) -> changeId ((++) n (getId r)) r) + r diff --git a/tests/compile-and-dump/GradingClient/Main.golden b/tests/compile-and-dump/GradingClient/Main.golden --- a/tests/compile-and-dump/GradingClient/Main.golden +++ b/tests/compile-and-dump/GradingClient/Main.golden @@ -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) diff --git a/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden b/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden --- a/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden +++ b/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden @@ -10,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)) diff --git a/tests/compile-and-dump/Promote/Constructors.golden b/tests/compile-and-dump/Promote/Constructors.golden --- a/tests/compile-and-dump/Promote/Constructors.golden +++ b/tests/compile-and-dump/Promote/Constructors.golden @@ -13,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 diff --git a/tests/compile-and-dump/Promote/GenDefunSymbols.golden b/tests/compile-and-dump/Promote/GenDefunSymbols.golden --- a/tests/compile-and-dump/Promote/GenDefunSymbols.golden +++ b/tests/compile-and-dump/Promote/GenDefunSymbols.golden @@ -7,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 ((,) (::+@#@$$###) ()) diff --git a/tests/compile-and-dump/Promote/Newtypes.golden b/tests/compile-and-dump/Promote/Newtypes.golden --- a/tests/compile-and-dump/Promote/Newtypes.golden +++ b/tests/compile-and-dump/Promote/Newtypes.golden @@ -14,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 diff --git a/tests/compile-and-dump/Promote/Prelude.golden b/tests/compile-and-dump/Promote/Prelude.golden --- a/tests/compile-and-dump/Promote/Prelude.golden +++ b/tests/compile-and-dump/Promote/Prelude.golden @@ -9,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 diff --git a/tests/compile-and-dump/Promote/T180.golden b/tests/compile-and-dump/Promote/T180.golden --- a/tests/compile-and-dump/Promote/T180.golden +++ b/tests/compile-and-dump/Promote/T180.golden @@ -13,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 diff --git a/tests/compile-and-dump/Promote/T361.golden b/tests/compile-and-dump/Promote/T361.golden --- a/tests/compile-and-dump/Promote/T361.golden +++ b/tests/compile-and-dump/Promote/T361.golden @@ -1,8 +1,8 @@ Promote/T361.hs:0:0:: Splicing declarations genDefunSymbols [''Proxy] ======> - type ProxySym0 :: forall k (t :: k). Proxy t - 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 diff --git a/tests/compile-and-dump/Promote/T601a.golden b/tests/compile-and-dump/Promote/T601a.golden new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Promote/T601a.golden @@ -0,0 +1,73 @@ +Promote/T601a.hs:(0,0)-(0,0): Splicing declarations + promote + [d| type MyApplicative :: (Type -> Type) -> Constraint + + class Functor f => MyApplicative f where + ap :: f (a -> b) -> f a -> f b + rightSparrow :: f a -> f b -> f b + rightSparrow x y = ap (id <$ x) y |] + ======> + type MyApplicative :: (Type -> Type) -> Constraint + class Functor f => MyApplicative f where + ap :: f (a -> b) -> f a -> f b + rightSparrow :: f a -> f b -> f b + rightSparrow x y = ap (id <$ x) y + type ApSym0 :: forall (f :: Type -> Type) + a + b. (~>) (f ((~>) a b)) ((~>) (f a) (f b)) + data ApSym0 :: (~>) (f ((~>) a b)) ((~>) (f a) (f b)) + where + ApSym0KindInference :: SameKind (Apply ApSym0 arg) (ApSym1 arg) => + ApSym0 a0123456789876543210 + type instance Apply @(f ((~>) a b)) @((~>) (f a) (f b)) ApSym0 a0123456789876543210 = ApSym1 a0123456789876543210 + instance SuppressUnusedWarnings ApSym0 where + suppressUnusedWarnings = snd ((,) ApSym0KindInference ()) + type ApSym1 :: forall (f :: Type -> Type) a b. f ((~>) a b) + -> (~>) (f a) (f b) + data ApSym1 (a0123456789876543210 :: f ((~>) a b)) :: (~>) (f a) (f b) + where + ApSym1KindInference :: SameKind (Apply (ApSym1 a0123456789876543210) arg) (ApSym2 a0123456789876543210 arg) => + ApSym1 a0123456789876543210 a0123456789876543210 + type instance Apply @(f a) @(f b) (ApSym1 a0123456789876543210) a0123456789876543210 = Ap a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (ApSym1 a0123456789876543210) where + suppressUnusedWarnings = snd ((,) ApSym1KindInference ()) + type ApSym2 :: forall (f :: Type -> Type) a b. f ((~>) a b) + -> f a -> f b + type family ApSym2 @(f :: Type + -> Type) @a @b (a0123456789876543210 :: f ((~>) a b)) (a0123456789876543210 :: f a) :: f b where + ApSym2 a0123456789876543210 a0123456789876543210 = Ap a0123456789876543210 a0123456789876543210 + type RightSparrowSym0 :: forall (f :: Type -> Type) + a + b. (~>) (f a) ((~>) (f b) (f b)) + data RightSparrowSym0 :: (~>) (f a) ((~>) (f b) (f b)) + where + RightSparrowSym0KindInference :: SameKind (Apply RightSparrowSym0 arg) (RightSparrowSym1 arg) => + RightSparrowSym0 a0123456789876543210 + type instance Apply @(f a) @((~>) (f b) (f b)) RightSparrowSym0 a0123456789876543210 = RightSparrowSym1 a0123456789876543210 + instance SuppressUnusedWarnings RightSparrowSym0 where + suppressUnusedWarnings = snd ((,) RightSparrowSym0KindInference ()) + type RightSparrowSym1 :: forall (f :: Type -> Type) a b. f a + -> (~>) (f b) (f b) + data RightSparrowSym1 (a0123456789876543210 :: f a) :: (~>) (f b) (f b) + where + RightSparrowSym1KindInference :: SameKind (Apply (RightSparrowSym1 a0123456789876543210) arg) (RightSparrowSym2 a0123456789876543210 arg) => + RightSparrowSym1 a0123456789876543210 a0123456789876543210 + type instance Apply @(f b) @(f b) (RightSparrowSym1 a0123456789876543210) a0123456789876543210 = RightSparrow a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (RightSparrowSym1 a0123456789876543210) where + suppressUnusedWarnings = snd ((,) RightSparrowSym1KindInference ()) + type RightSparrowSym2 :: forall (f :: Type -> Type) a b. f a + -> f b -> f b + type family RightSparrowSym2 @(f :: Type + -> Type) @a @b (a0123456789876543210 :: f a) (a0123456789876543210 :: f b) :: f b where + RightSparrowSym2 a0123456789876543210 a0123456789876543210 = RightSparrow a0123456789876543210 a0123456789876543210 + type RightSparrow_0123456789876543210 :: forall (f :: Type -> Type) + a + b. f a -> f b -> f b + type family RightSparrow_0123456789876543210 @(f :: Type + -> Type) @a @b (a :: f a) (a :: f b) :: f b where + RightSparrow_0123456789876543210 @f @a @b (x :: f a) (y :: f b) = Apply (Apply ApSym0 (Apply (Apply (<$@#@$) IdSym0) x)) y + type PMyApplicative :: (Type -> Type) -> Constraint + class PMyApplicative f where + type family Ap (arg :: f ((~>) a b)) (arg :: f a) :: f b + type family RightSparrow (arg :: f a) (arg :: f b) :: f b + type RightSparrow a a = RightSparrow_0123456789876543210 a a diff --git a/tests/compile-and-dump/Promote/T601a.hs b/tests/compile-and-dump/Promote/T601a.hs new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Promote/T601a.hs @@ -0,0 +1,14 @@ +module T601a where + +import Data.Kind +import Data.Singletons.Base.TH +import Prelude.Singletons + +$(promote [d| + type MyApplicative :: (Type -> Type) -> Constraint + class Functor f => MyApplicative f where + ap :: f (a -> b) -> f a -> f b + + rightSparrow :: f a -> f b -> f b + rightSparrow x y = ap (id <$ x) y + |]) diff --git a/tests/compile-and-dump/Promote/T605.golden b/tests/compile-and-dump/Promote/T605.golden new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Promote/T605.golden @@ -0,0 +1,39 @@ +Promote/T605.hs:(0,0)-(0,0): Splicing declarations + promoteOnly + [d| type Traversable' :: (Type -> Type) -> Constraint + + class (Functor t, Foldable t) => Traversable' t where + traverse' :: Applicative f => (a -> f b) -> t a -> t (f b) |] + ======> + type Traverse'Sym0 :: forall (t :: Type -> Type) + a + f + b. (~>) ((~>) a (f b)) ((~>) (t a) (t (f b))) + data Traverse'Sym0 :: (~>) ((~>) a (f b)) ((~>) (t a) (t (f b))) + where + Traverse'Sym0KindInference :: SameKind (Apply Traverse'Sym0 arg) (Traverse'Sym1 arg) => + Traverse'Sym0 a0123456789876543210 + type instance Apply @((~>) a (f b)) @((~>) (t a) (t (f b))) Traverse'Sym0 a0123456789876543210 = Traverse'Sym1 a0123456789876543210 + instance SuppressUnusedWarnings Traverse'Sym0 where + suppressUnusedWarnings = snd ((,) Traverse'Sym0KindInference ()) + type Traverse'Sym1 :: forall (t :: Type -> Type) + a + f + b. (~>) a (f b) -> (~>) (t a) (t (f b)) + data Traverse'Sym1 (a0123456789876543210 :: (~>) a (f b)) :: (~>) (t a) (t (f b)) + where + Traverse'Sym1KindInference :: SameKind (Apply (Traverse'Sym1 a0123456789876543210) arg) (Traverse'Sym2 a0123456789876543210 arg) => + Traverse'Sym1 a0123456789876543210 a0123456789876543210 + type instance Apply @(t a) @(t (f b)) (Traverse'Sym1 a0123456789876543210) a0123456789876543210 = Traverse' a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (Traverse'Sym1 a0123456789876543210) where + suppressUnusedWarnings = snd ((,) Traverse'Sym1KindInference ()) + type Traverse'Sym2 :: forall (t :: Type -> Type) + a + f + b. (~>) a (f b) -> t a -> t (f b) + type family Traverse'Sym2 @(t :: Type + -> Type) @a @f @b (a0123456789876543210 :: (~>) a (f b)) (a0123456789876543210 :: t a) :: t (f b) where + Traverse'Sym2 a0123456789876543210 a0123456789876543210 = Traverse' a0123456789876543210 a0123456789876543210 + type PTraversable' :: (Type -> Type) -> Constraint + class PTraversable' t where + type family Traverse' (arg :: (~>) a (f b)) (arg :: t a) :: t (f b) diff --git a/tests/compile-and-dump/Promote/T605.hs b/tests/compile-and-dump/Promote/T605.hs new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Promote/T605.hs @@ -0,0 +1,11 @@ +module T605 where + +import Data.Kind +import Data.Singletons.Base.TH +import Prelude.Singletons + +$(promoteOnly [d| + type Traversable' :: (Type -> Type) -> Constraint + class (Functor t, Foldable t) => Traversable' t where + traverse' :: Applicative f => (a -> f b) -> t a -> t (f b) + |]) diff --git a/tests/compile-and-dump/Promote/T613.golden b/tests/compile-and-dump/Promote/T613.golden new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Promote/T613.golden @@ -0,0 +1,31 @@ +Promote/T613.hs:(0,0)-(0,0): Splicing declarations + promote + [d| f :: forall k (a :: k). Proxy a -> Proxy a + f x + = y + where + y = x |] + ======> + f :: forall k (a :: k). Proxy a -> Proxy a + f x + = y + where + y = x + type family Let0123456789876543210YSym0 k0123456789876543210 (a0123456789876543210 :: k0123456789876543210) (x0123456789876543210 :: Proxy a0123456789876543210) where + Let0123456789876543210YSym0 k0123456789876543210 a0123456789876543210 x0123456789876543210 = Let0123456789876543210Y k0123456789876543210 a0123456789876543210 x0123456789876543210 + type family Let0123456789876543210Y k0123456789876543210 (a0123456789876543210 :: k0123456789876543210) (x0123456789876543210 :: Proxy a0123456789876543210) where + Let0123456789876543210Y k a x = x + type FSym0 :: forall k (a :: k). (~>) (Proxy a) (Proxy a) + data FSym0 :: (~>) (Proxy a) (Proxy a) + where + FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) => + FSym0 a0123456789876543210 + type instance Apply @(Proxy a) @(Proxy a) FSym0 a0123456789876543210 = F a0123456789876543210 + instance SuppressUnusedWarnings FSym0 where + suppressUnusedWarnings = snd ((,) FSym0KindInference ()) + type FSym1 :: forall k (a :: k). Proxy a -> Proxy a + type family FSym1 @k @(a :: k) (a0123456789876543210 :: Proxy a) :: Proxy a where + FSym1 a0123456789876543210 = F a0123456789876543210 + type F :: forall k (a :: k). Proxy a -> Proxy a + type family F @k @(a :: k) (a :: Proxy a) :: Proxy a where + F @k @a (x :: Proxy a) = Let0123456789876543210YSym0 k a x diff --git a/tests/compile-and-dump/Promote/T613.hs b/tests/compile-and-dump/Promote/T613.hs new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Promote/T613.hs @@ -0,0 +1,12 @@ +module T613 where + +import Data.Proxy +import Data.Proxy.Singletons +import Data.Singletons.TH + +$(promote [d| + f :: forall k (a :: k). Proxy a -> Proxy a + f x = y + where + y = x + |]) diff --git a/tests/compile-and-dump/Singletons/AsPattern.golden b/tests/compile-and-dump/Singletons/AsPattern.golden --- a/tests/compile-and-dump/Singletons/AsPattern.golden +++ b/tests/compile-and-dump/Singletons/AsPattern.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/BoundedDeriving.golden b/tests/compile-and-dump/Singletons/BoundedDeriving.golden --- a/tests/compile-and-dump/Singletons/BoundedDeriving.golden +++ b/tests/compile-and-dump/Singletons/BoundedDeriving.golden @@ -54,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 diff --git a/tests/compile-and-dump/Singletons/BoxUnBox.golden b/tests/compile-and-dump/Singletons/BoxUnBox.golden --- a/tests/compile-and-dump/Singletons/BoxUnBox.golden +++ b/tests/compile-and-dump/Singletons/BoxUnBox.golden @@ -13,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 diff --git a/tests/compile-and-dump/Singletons/CaseExpressions.golden b/tests/compile-and-dump/Singletons/CaseExpressions.golden --- a/tests/compile-and-dump/Singletons/CaseExpressions.golden +++ b/tests/compile-and-dump/Singletons/CaseExpressions.golden @@ -37,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 diff --git a/tests/compile-and-dump/Singletons/Classes.golden b/tests/compile-and-dump/Singletons/Classes.golden --- a/tests/compile-and-dump/Singletons/Classes.golden +++ b/tests/compile-and-dump/Singletons/Classes.golden @@ -16,20 +16,20 @@ data Foo = A | B data Foo2 = F | G + instance Eq Foo2 where + F == F = True + G == G = True + F == G = False + G == F = False + instance MyOrd Foo where + mycompare = fooCompare instance MyOrd () where mycompare _ = const EQ instance MyOrd Nat where Zero `mycompare` Zero = EQ Zero `mycompare` (Succ _) = LT (Succ _) `mycompare` Zero = GT - (Succ n) `mycompare` (Succ m) = m `mycompare` n - instance MyOrd Foo where - mycompare = fooCompare - instance Eq Foo2 where - F == F = True - G == G = True - F == G = False - G == F = False |] + (Succ n) `mycompare` (Succ m) = m `mycompare` n |] ======> const :: a -> b -> a const x _ = x @@ -76,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 diff --git a/tests/compile-and-dump/Singletons/Classes2.golden b/tests/compile-and-dump/Singletons/Classes2.golden --- a/tests/compile-and-dump/Singletons/Classes2.golden +++ b/tests/compile-and-dump/Singletons/Classes2.golden @@ -22,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 diff --git a/tests/compile-and-dump/Singletons/Contains.golden b/tests/compile-and-dump/Singletons/Contains.golden --- a/tests/compile-and-dump/Singletons/Contains.golden +++ b/tests/compile-and-dump/Singletons/Contains.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/DataValues.golden b/tests/compile-and-dump/Singletons/DataValues.golden --- a/tests/compile-and-dump/Singletons/DataValues.golden +++ b/tests/compile-and-dump/Singletons/DataValues.golden @@ -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 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 + type ShowsPrec_0123456789876543210 :: forall a + b. GHC.Internal.Bignum.Natural.Natural + -> Pair a b -> Symbol -> Symbol + type family ShowsPrec_0123456789876543210 @a @b (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Pair a b) (a :: Symbol) :: Symbol where + ShowsPrec_0123456789876543210 @a @b (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (Pair arg_0123456789876543210 arg_0123456789876543210 :: Pair a b) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Pair ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 instance PShow (Pair a b) where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a - sAList :: Sing @_ AListSym0 - sTuple :: Sing @_ TupleSym0 - sComplex :: Sing @_ ComplexSym0 - sPr :: Sing @_ PrSym0 + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a + sAList :: Sing @_ AList + sTuple :: Sing @_ Tuple + sComplex :: Sing @_ Complex + sPr :: Sing @_ Pr sAList = applySing (applySing (singFun2 @(:@#@$) SCons) SZero) @@ -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) diff --git a/tests/compile-and-dump/Singletons/Empty.golden b/tests/compile-and-dump/Singletons/Empty.golden --- a/tests/compile-and-dump/Singletons/Empty.golden +++ b/tests/compile-and-dump/Singletons/Empty.golden @@ -6,5 +6,5 @@ type instance Sing @Empty = SEmpty instance SingKind Empty where type Demote Empty = Empty - fromSing x = case x of {} - toSing x = SomeSing (case x of {}) + fromSing x = (\case) x + toSing x = SomeSing ((\case) x) diff --git a/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden b/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden --- a/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden +++ b/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden @@ -6,68 +6,41 @@ ======> data Foo deriving instance Show Foo - type family Case_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t where - type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural - -> Foo -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Foo) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where - ShowsPrec_0123456789876543210 _ v_0123456789876543210 a_0123456789876543210 = Apply (Case_0123456789876543210 v_0123456789876543210 a_0123456789876543210 v_0123456789876543210) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - where - ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => - ShowsPrec_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym0KindInference ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural - -> (~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol) - where - ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym1KindInference ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural - -> Foo -> (~>) GHC.Types.Symbol GHC.Types.Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo) :: (~>) GHC.Types.Symbol GHC.Types.Symbol + type family LamCases_0123456789876543210 (v_01234567898765432100123456789876543210 :: Foo) (a_01234567898765432100123456789876543210 :: GHC.Internal.Types.Symbol) a_0123456789876543210 where + data LamCases_0123456789876543210Sym0 (v_01234567898765432100123456789876543210 :: Foo) (a_01234567898765432100123456789876543210 :: GHC.Internal.Types.Symbol) a_01234567898765432100123456789876543210 where - ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) => + LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym2KindInference ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural - -> Foo -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where - ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 (v_01234567898765432100123456789876543210 :: Foo) (a_01234567898765432100123456789876543210 :: GHC.Internal.Types.Symbol) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 v_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural + -> Foo + -> GHC.Internal.Types.Symbol + -> GHC.Internal.Types.Symbol + type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Foo) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where + ShowsPrec_0123456789876543210 _ v_0123456789876543210 a_0123456789876543210 = Apply (Apply (LamCases_0123456789876543210Sym0 v_0123456789876543210 a_0123456789876543210) v_0123456789876543210) a_0123456789876543210 instance PShow Foo where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a data SFoo :: Foo -> Type type instance Sing @Foo = SFoo instance SingKind Foo where type Demote Foo = Foo - fromSing x = case x of {} - toSing x = SomeSing (case x of {}) + fromSing x = (\case) x + toSing x = SomeSing ((\case) x) instance SShow Foo where - sShowsPrec :: - forall (t1 :: GHC.Num.Natural.Natural) - (t2 :: Foo) - (t3 :: GHC.Types.Symbol). Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - -> Type) t1) t2) t3) sShowsPrec _ (sV_0123456789876543210 :: Sing v_0123456789876543210) (sA_0123456789876543210 :: Sing a_0123456789876543210) = applySing - (id - @(Sing (Case_0123456789876543210 v_0123456789876543210 a_0123456789876543210 v_0123456789876543210)) - (case sV_0123456789876543210 of {})) + (applySing + (singFun1 + @(LamCases_0123456789876543210Sym0 v_0123456789876543210 a_0123456789876543210) + (\case)) + sV_0123456789876543210) sA_0123456789876543210 deriving instance Show (SFoo (z :: Foo)) diff --git a/tests/compile-and-dump/Singletons/EnumDeriving.golden b/tests/compile-and-dump/Singletons/EnumDeriving.golden --- a/tests/compile-and-dump/Singletons/EnumDeriving.golden +++ b/tests/compile-and-dump/Singletons/EnumDeriving.golden @@ -24,52 +24,58 @@ type Q2Sym0 :: Quux type family Q2Sym0 :: Quux where Q2Sym0 = Q2 - type family Case_0123456789876543210 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.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 n 'True = BumSym0 + LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument" + data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where - ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) => - ToEnum_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) => + LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where suppressUnusedWarnings - = snd ((,) ToEnum_0123456789876543210Sym0KindInference ()) - type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural - -> Foo - type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: Foo where - ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - type FromEnum_0123456789876543210 :: Foo -> GHC.Num.Natural.Natural - type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Num.Natural.Natural where + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 n 'True = BazSym0 + LamCases_0123456789876543210 n 'False = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 2)) + data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 + where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) => + LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where + suppressUnusedWarnings + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 n 'True = BarSym0 + LamCases_0123456789876543210 n 'False = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 1)) + data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 + where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) => + LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where + suppressUnusedWarnings + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural + -> Foo + type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: Foo where + ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0)) + type FromEnum_0123456789876543210 :: Foo + -> GHC.Internal.Bignum.Natural.Natural + type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Internal.Bignum.Natural.Natural where FromEnum_0123456789876543210 Bar = FromInteger 0 FromEnum_0123456789876543210 Baz = FromInteger 1 FromEnum_0123456789876543210 Bum = FromInteger 2 - type FromEnum_0123456789876543210Sym0 :: (~>) Foo GHC.Num.Natural.Natural - data FromEnum_0123456789876543210Sym0 :: (~>) Foo GHC.Num.Natural.Natural - where - FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) => - FromEnum_0123456789876543210Sym0 a0123456789876543210 - type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) FromEnum_0123456789876543210Sym0KindInference ()) - type FromEnum_0123456789876543210Sym1 :: Foo - -> GHC.Num.Natural.Natural - type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Foo) :: GHC.Num.Natural.Natural where - FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 instance PEnum Foo where - type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a - type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a + type ToEnum a = ToEnum_0123456789876543210 a + type FromEnum a = FromEnum_0123456789876543210 a data SFoo :: Foo -> Type where SBar :: SFoo (Bar :: Foo) @@ -96,42 +102,37 @@ toSing Q1 = SomeSing SQ1 toSing Q2 = SomeSing SQ2 instance SEnum Foo where - sToEnum :: - forall (t :: GHC.Num.Natural.Natural). Sing t - -> Sing (Apply (Data.Singletons.Base.Enum.ToEnumSym0 :: TyFun GHC.Num.Natural.Natural Foo - -> Type) t) - sFromEnum :: - forall (t :: Foo). Sing t - -> Sing (Apply (Data.Singletons.Base.Enum.FromEnumSym0 :: TyFun Foo GHC.Num.Natural.Natural - -> Type) t) sToEnum (sN :: Sing n) - = id - @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)))) - (case - applySing - (applySing (singFun2 @(==@#@$) (%==)) sN) - (sFromInteger (sing :: Sing 0)) - of - STrue -> SBar - SFalse - -> id - @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1)))) - (case - applySing - (applySing (singFun2 @(==@#@$) (%==)) sN) - (sFromInteger (sing :: Sing 1)) - of - STrue -> SBaz - SFalse - -> id - @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 2)))) - (case - applySing - (applySing (singFun2 @(==@#@$) (%==)) sN) - (sFromInteger (sing :: Sing 2)) - of - STrue -> SBum - SFalse -> sError (sing :: Sing "toEnum: bad argument")))) + = applySing + (singFun1 + @(LamCases_0123456789876543210Sym0 n) + (\cases + STrue -> SBar + SFalse + -> applySing + (singFun1 + @(LamCases_0123456789876543210Sym0 n) + (\cases + STrue -> SBaz + SFalse + -> applySing + (singFun1 + @(LamCases_0123456789876543210Sym0 n) + (\cases + STrue -> SBum + SFalse + -> applySing + (singFun1 @ErrorSym0 sError) + (sing :: Sing "toEnum: bad argument"))) + (applySing + (applySing (singFun2 @(==@#@$) (%==)) sN) + (sFromInteger (sing :: Sing 2))))) + (applySing + (applySing (singFun2 @(==@#@$) (%==)) sN) + (sFromInteger (sing :: Sing 1))))) + (applySing + (applySing (singFun2 @(==@#@$) (%==)) sN) + (sFromInteger (sing :: Sing 0))) sFromEnum SBar = sFromInteger (sing :: Sing 0) sFromEnum SBaz = sFromInteger (sing :: Sing 1) sFromEnum SBum = sFromInteger (sing :: Sing 2) @@ -148,76 +149,66 @@ 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.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 n 'True = Q2Sym0 + LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument" + data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where - ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) => - ToEnum_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) => + LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where suppressUnusedWarnings - = snd ((,) ToEnum_0123456789876543210Sym0KindInference ()) - type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural - -> Quux - type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: Quux where - ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 n 'True = Q1Sym0 + LamCases_0123456789876543210 n 'False = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 1)) + data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 + where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) => + LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where + suppressUnusedWarnings + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural + -> Quux + type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: Quux where + ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0)) type FromEnum_0123456789876543210 :: Quux - -> GHC.Num.Natural.Natural - type family FromEnum_0123456789876543210 (a :: Quux) :: GHC.Num.Natural.Natural where + -> GHC.Internal.Bignum.Natural.Natural + type family FromEnum_0123456789876543210 (a :: Quux) :: GHC.Internal.Bignum.Natural.Natural where FromEnum_0123456789876543210 'Q1 = FromInteger 0 FromEnum_0123456789876543210 'Q2 = FromInteger 1 - type FromEnum_0123456789876543210Sym0 :: (~>) Quux GHC.Num.Natural.Natural - data FromEnum_0123456789876543210Sym0 :: (~>) Quux GHC.Num.Natural.Natural - where - FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) => - FromEnum_0123456789876543210Sym0 a0123456789876543210 - type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) FromEnum_0123456789876543210Sym0KindInference ()) - type FromEnum_0123456789876543210Sym1 :: Quux - -> GHC.Num.Natural.Natural - type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Quux) :: GHC.Num.Natural.Natural where - FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 instance PEnum Quux where - type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a - type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a + type ToEnum a = ToEnum_0123456789876543210 a + type FromEnum a = FromEnum_0123456789876543210 a instance SEnum Quux where - sToEnum :: - forall (t :: GHC.Num.Natural.Natural). Sing t - -> Sing (Apply (Data.Singletons.Base.Enum.ToEnumSym0 :: TyFun GHC.Num.Natural.Natural Quux - -> Type) t) - sFromEnum :: - forall (t :: Quux). Sing t - -> Sing (Apply (Data.Singletons.Base.Enum.FromEnumSym0 :: TyFun Quux GHC.Num.Natural.Natural - -> Type) t) sToEnum (sN :: Sing n) - = id - @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)))) - (case - applySing - (applySing (singFun2 @(==@#@$) (%==)) sN) - (sFromInteger (sing :: Sing 0)) - of - STrue -> SQ1 - SFalse - -> id - @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1)))) - (case - applySing - (applySing (singFun2 @(==@#@$) (%==)) sN) - (sFromInteger (sing :: Sing 1)) - of - STrue -> SQ2 - SFalse -> sError (sing :: Sing "toEnum: bad argument"))) + = applySing + (singFun1 + @(LamCases_0123456789876543210Sym0 n) + (\cases + STrue -> SQ1 + SFalse + -> applySing + (singFun1 + @(LamCases_0123456789876543210Sym0 n) + (\cases + STrue -> SQ2 + SFalse + -> applySing + (singFun1 @ErrorSym0 sError) + (sing :: Sing "toEnum: bad argument"))) + (applySing + (applySing (singFun2 @(==@#@$) (%==)) sN) + (sFromInteger (sing :: Sing 1))))) + (applySing + (applySing (singFun2 @(==@#@$) (%==)) sN) + (sFromInteger (sing :: Sing 0))) sFromEnum SQ1 = sFromInteger (sing :: Sing 0) sFromEnum SQ2 = sFromInteger (sing :: Sing 1) diff --git a/tests/compile-and-dump/Singletons/EqInstances.golden b/tests/compile-and-dump/Singletons/EqInstances.golden --- a/tests/compile-and-dump/Singletons/EqInstances.golden +++ b/tests/compile-and-dump/Singletons/EqInstances.golden @@ -7,35 +7,9 @@ TFHelper_0123456789876543210 'FLeaf ('(:+:) _ _) = FalseSym0 TFHelper_0123456789876543210 ('(:+:) _ _) 'FLeaf = FalseSym0 TFHelper_0123456789876543210 ('(:+:) a_0123456789876543210 a_0123456789876543210) ('(:+:) b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210) - type TFHelper_0123456789876543210Sym0 :: (~>) Foo ((~>) Foo Bool) - data TFHelper_0123456789876543210Sym0 :: (~>) Foo ((~>) Foo Bool) - where - TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) => - TFHelper_0123456789876543210Sym0 a0123456789876543210 - type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) TFHelper_0123456789876543210Sym0KindInference ()) - type TFHelper_0123456789876543210Sym1 :: Foo -> (~>) Foo Bool - data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Foo) :: (~>) Foo Bool - where - TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) => - TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) TFHelper_0123456789876543210Sym1KindInference ()) - type TFHelper_0123456789876543210Sym2 :: Foo -> Foo -> Bool - type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Foo) (a0123456789876543210 :: Foo) :: Bool where - TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 instance PEq Foo where - type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a + type (==) a a = TFHelper_0123456789876543210 a a instance SEq Foo => SEq Foo where - (%==) :: - forall (t1 :: Foo) (t2 :: Foo). Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun Foo ((~>) Foo Bool) - -> Type) t1) t2) (%==) SFLeaf SFLeaf = STrue (%==) SFLeaf ((:%+:) _ _) = SFalse (%==) ((:%+:) _ _) SFLeaf = SFalse @@ -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 diff --git a/tests/compile-and-dump/Singletons/Error.golden b/tests/compile-and-dump/Singletons/Error.golden --- a/tests/compile-and-dump/Singletons/Error.golden +++ b/tests/compile-and-dump/Singletons/Error.golden @@ -12,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 diff --git a/tests/compile-and-dump/Singletons/Fixity.golden b/tests/compile-and-dump/Singletons/Fixity.golden --- a/tests/compile-and-dump/Singletons/Fixity.golden +++ b/tests/compile-and-dump/Singletons/Fixity.golden @@ -20,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 @(<=>@#@$) (%<=>) diff --git a/tests/compile-and-dump/Singletons/FunDeps.golden b/tests/compile-and-dump/Singletons/FunDeps.golden --- a/tests/compile-and-dump/Singletons/FunDeps.golden +++ b/tests/compile-and-dump/Singletons/FunDeps.golden @@ -28,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) diff --git a/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden b/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden --- a/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden +++ b/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden @@ -15,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 diff --git a/tests/compile-and-dump/Singletons/HigherOrder.golden b/tests/compile-and-dump/Singletons/HigherOrder.golden --- a/tests/compile-and-dump/Singletons/HigherOrder.golden +++ b/tests/compile-and-dump/Singletons/HigherOrder.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/LambdaCase.golden b/tests/compile-and-dump/Singletons/LambdaCase.golden --- a/tests/compile-and-dump/Singletons/LambdaCase.golden +++ b/tests/compile-and-dump/Singletons/LambdaCase.golden @@ -29,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 diff --git a/tests/compile-and-dump/Singletons/Lambdas.golden b/tests/compile-and-dump/Singletons/Lambdas.golden --- a/tests/compile-and-dump/Singletons/Lambdas.golden +++ b/tests/compile-and-dump/Singletons/Lambdas.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/LambdasComprehensive.golden b/tests/compile-and-dump/Singletons/LambdasComprehensive.golden --- a/tests/compile-and-dump/Singletons/LambdasComprehensive.golden +++ b/tests/compile-and-dump/Singletons/LambdasComprehensive.golden @@ -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) diff --git a/tests/compile-and-dump/Singletons/LetStatements.golden b/tests/compile-and-dump/Singletons/LetStatements.golden --- a/tests/compile-and-dump/Singletons/LetStatements.golden +++ b/tests/compile-and-dump/Singletons/LetStatements.golden @@ -189,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 diff --git a/tests/compile-and-dump/Singletons/Maybe.golden b/tests/compile-and-dump/Singletons/Maybe.golden --- a/tests/compile-and-dump/Singletons/Maybe.golden +++ b/tests/compile-and-dump/Singletons/Maybe.golden @@ -15,82 +15,30 @@ 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 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 + type (==) a a = TFHelper_0123456789876543210 a a + type ShowsPrec_0123456789876543210 :: forall a. GHC.Internal.Bignum.Natural.Natural + -> Maybe a + -> GHC.Internal.Types.Symbol + -> GHC.Internal.Types.Symbol + type family ShowsPrec_0123456789876543210 @a (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Maybe a) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where + ShowsPrec_0123456789876543210 @a (_ :: GHC.Internal.Bignum.Natural.Natural) (Nothing :: Maybe a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply ShowStringSym0 "Nothing") a_0123456789876543210 + ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (Just arg_0123456789876543210 :: Maybe a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Just ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210 instance PShow (Maybe a) where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a data SMaybe :: forall a. Maybe a -> Type where SNothing :: forall a. SMaybe (Nothing :: Maybe a) @@ -102,13 +50,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 +63,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 +95,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 => diff --git a/tests/compile-and-dump/Singletons/Nat.golden b/tests/compile-and-dump/Singletons/Nat.golden --- a/tests/compile-and-dump/Singletons/Nat.golden +++ b/tests/compile-and-dump/Singletons/Nat.golden @@ -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,30 @@ TFHelper_0123456789876543210 Zero (Succ _) = FalseSym0 TFHelper_0123456789876543210 (Succ _) Zero = FalseSym0 TFHelper_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210 - type TFHelper_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Bool) - data TFHelper_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Bool) - where - TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) => - TFHelper_0123456789876543210Sym0 a0123456789876543210 - type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) TFHelper_0123456789876543210Sym0KindInference ()) - type TFHelper_0123456789876543210Sym1 :: Nat -> (~>) Nat Bool - data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Bool - where - TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) => - TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) TFHelper_0123456789876543210Sym1KindInference ()) - type TFHelper_0123456789876543210Sym2 :: Nat -> Nat -> Bool - type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Bool where - TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 instance PEq Nat where - type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a - type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural - -> Nat -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Nat) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type (==) a a = TFHelper_0123456789876543210 a a + type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural + -> Nat + -> GHC.Internal.Types.Symbol + -> GHC.Internal.Types.Symbol + type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Nat) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where ShowsPrec_0123456789876543210 _ Zero a_0123456789876543210 = Apply (Apply ShowStringSym0 "Zero") a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 (Succ arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Succ ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - where - ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => - ShowsPrec_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym0KindInference ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural - -> (~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol) - where - ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym1KindInference ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural - -> Nat -> (~>) GHC.Types.Symbol GHC.Types.Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Nat) :: (~>) GHC.Types.Symbol GHC.Types.Symbol - where - ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym2KindInference ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural - -> Nat -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Nat) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where - ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow Nat where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a type Compare_0123456789876543210 :: Nat -> Nat -> Ordering type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 (<>@#@$)) 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 +134,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 +147,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 +178,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 +202,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 => diff --git a/tests/compile-and-dump/Singletons/Natural.golden b/tests/compile-and-dump/Singletons/Natural.golden --- a/tests/compile-and-dump/Singletons/Natural.golden +++ b/tests/compile-and-dump/Singletons/Natural.golden @@ -15,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 diff --git a/tests/compile-and-dump/Singletons/NegativeLiterals.golden b/tests/compile-and-dump/Singletons/NegativeLiterals.golden --- a/tests/compile-and-dump/Singletons/NegativeLiterals.golden +++ b/tests/compile-and-dump/Singletons/NegativeLiterals.golden @@ -11,11 +11,11 @@ type F :: Natural type family F :: Natural where F = Negate (FromInteger 1) - sF :: (Sing (FSym0 :: Natural) :: 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| | ^^^^^^^^^^^^^^^... + diff --git a/tests/compile-and-dump/Singletons/Operators.golden b/tests/compile-and-dump/Singletons/Operators.golden --- a/tests/compile-and-dump/Singletons/Operators.golden +++ b/tests/compile-and-dump/Singletons/Operators.golden @@ -30,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) => diff --git a/tests/compile-and-dump/Singletons/OrdDeriving.golden b/tests/compile-and-dump/Singletons/OrdDeriving.golden --- a/tests/compile-and-dump/Singletons/OrdDeriving.golden +++ b/tests/compile-and-dump/Singletons/OrdDeriving.golden @@ -31,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) => diff --git a/tests/compile-and-dump/Singletons/OverloadedStrings.golden b/tests/compile-and-dump/Singletons/OverloadedStrings.golden --- a/tests/compile-and-dump/Singletons/OverloadedStrings.golden +++ b/tests/compile-and-dump/Singletons/OverloadedStrings.golden @@ -17,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")) diff --git a/tests/compile-and-dump/Singletons/PatternMatching.golden b/tests/compile-and-dump/Singletons/PatternMatching.golden --- a/tests/compile-and-dump/Singletons/PatternMatching.golden +++ b/tests/compile-and-dump/Singletons/PatternMatching.golden @@ -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 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 + type ShowsPrec_0123456789876543210 :: forall a + b. GHC.Internal.Bignum.Natural.Natural + -> Pair a b -> Symbol -> Symbol + type family ShowsPrec_0123456789876543210 @a @b (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Pair a b) (a :: Symbol) :: Symbol where + ShowsPrec_0123456789876543210 @a @b (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (Pair arg_0123456789876543210 arg_0123456789876543210 :: Pair a b) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Pair ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 instance PShow (Pair a b) where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a - sAList :: Sing @_ AListSym0 - sTuple :: Sing @_ TupleSym0 - sComplex :: Sing @_ ComplexSym0 - sPr :: Sing @_ PrSym0 + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a + sAList :: Sing @_ AList + sTuple :: Sing @_ Tuple + sComplex :: Sing @_ Complex + sPr :: Sing @_ Pr sAList = applySing (applySing (singFun2 @(:@#@$) SCons) SZero) @@ -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 diff --git a/tests/compile-and-dump/Singletons/PolyKinds.golden b/tests/compile-and-dump/Singletons/PolyKinds.golden --- a/tests/compile-and-dump/Singletons/PolyKinds.golden +++ b/tests/compile-and-dump/Singletons/PolyKinds.golden @@ -10,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 diff --git a/tests/compile-and-dump/Singletons/PolyKindsApp.golden b/tests/compile-and-dump/Singletons/PolyKindsApp.golden --- a/tests/compile-and-dump/Singletons/PolyKindsApp.golden +++ b/tests/compile-and-dump/Singletons/PolyKindsApp.golden @@ -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) diff --git a/tests/compile-and-dump/Singletons/Records.golden b/tests/compile-and-dump/Singletons/Records.golden --- a/tests/compile-and-dump/Singletons/Records.golden +++ b/tests/compile-and-dump/Singletons/Records.golden @@ -8,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 diff --git a/tests/compile-and-dump/Singletons/ReturnFunc.golden b/tests/compile-and-dump/Singletons/ReturnFunc.golden --- a/tests/compile-and-dump/Singletons/ReturnFunc.golden +++ b/tests/compile-and-dump/Singletons/ReturnFunc.golden @@ -18,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 diff --git a/tests/compile-and-dump/Singletons/Sections.golden b/tests/compile-and-dump/Singletons/Sections.golden --- a/tests/compile-and-dump/Singletons/Sections.golden +++ b/tests/compile-and-dump/Singletons/Sections.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/ShowDeriving.golden b/tests/compile-and-dump/Singletons/ShowDeriving.golden --- a/tests/compile-and-dump/Singletons/ShowDeriving.golden +++ b/tests/compile-and-dump/Singletons/ShowDeriving.golden @@ -32,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 @@ -159,135 +159,34 @@ type GetFoo3a :: Foo3 -> Bool type family GetFoo3a (a :: Foo3) :: Bool where GetFoo3a (MkFoo3 field _) = field - type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural + type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural -> Foo1 -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Foo1) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Foo1) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 _ MkFoo1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "MkFoo1") a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo1 ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo1 ((~>) Symbol Symbol)) - where - ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => - ShowsPrec_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym0KindInference ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural - -> (~>) Foo1 ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Foo1 ((~>) Symbol Symbol) - where - ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym1KindInference ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural - -> Foo1 -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo1) :: (~>) Symbol Symbol - where - ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym2KindInference ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural - -> Foo1 -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo1) (a0123456789876543210 :: Symbol) :: Symbol where - ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow Foo1 where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a - type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural - -> Foo2 a -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 @a (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 + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a + type ShowsPrec_0123456789876543210 :: forall a. GHC.Internal.Bignum.Natural.Natural + -> Foo2 a -> Symbol -> Symbol + type family ShowsPrec_0123456789876543210 @a (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Foo2 a) (a :: Symbol) :: Symbol where + ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (MkFoo2a arg_0123456789876543210 arg_0123456789876543210 :: Foo2 a) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "MkFoo2a ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 + ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (MkFoo2b argL_0123456789876543210 argR_0123456789876543210 :: Foo2 a) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 5))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " `MkFoo2b` ")) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argR_0123456789876543210)))) a_0123456789876543210 + ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) ((:*:) arg_0123456789876543210 arg_0123456789876543210 :: Foo2 a) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "(:*:) ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 + ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) ((:&:) argL_0123456789876543210 argR_0123456789876543210 :: Foo2 a) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 5))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " :&: ")) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argR_0123456789876543210)))) a_0123456789876543210 instance PShow (Foo2 a) where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a - type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a + type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural -> Foo3 -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Foo3) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Foo3) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 p_0123456789876543210 (MkFoo3 arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "MkFoo3 ")) (Apply (Apply (.@#@$) (Apply ShowCharSym0 '{')) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "getFoo3a = ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 0)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowCommaSpaceSym0) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "(***) = ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 0)) arg_0123456789876543210)) (Apply ShowCharSym0 '}'))))))))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo3 ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo3 ((~>) Symbol Symbol)) - where - ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => - ShowsPrec_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym0KindInference ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural - -> (~>) Foo3 ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Foo3 ((~>) Symbol Symbol) - where - ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym1KindInference ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural - -> Foo3 -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo3) :: (~>) Symbol Symbol - where - ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym2KindInference ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural - -> Foo3 -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo3) (a0123456789876543210 :: Symbol) :: Symbol where - ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow Foo3 where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a - infixl 5 :%&: - infixl 5 :%*: - infixl 5 `SMkFoo2b` + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a + infixl 5 data :%&: + infixl 5 data :%*: + infixl 5 data `SMkFoo2b` (%***) :: - (forall (t :: Foo3). - Sing t -> Sing (Apply (***@#@$) t :: Bool) :: 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) diff --git a/tests/compile-and-dump/Singletons/StandaloneDeriving.golden b/tests/compile-and-dump/Singletons/StandaloneDeriving.golden --- a/tests/compile-and-dump/Singletons/StandaloneDeriving.golden +++ b/tests/compile-and-dump/Singletons/StandaloneDeriving.golden @@ -30,278 +30,118 @@ where (::*:@#@$###) :: SameKind (Apply (:*:@#@$) arg) ((:*:@#@$$) arg) => (:*:@#@$) a0123456789876543210 - type instance Apply (:*:@#@$) a0123456789876543210 = (:*:@#@$$) a0123456789876543210 + type instance Apply @a @((~>) b (T a b)) (:*:@#@$) a0123456789876543210 = (:*:@#@$$) a0123456789876543210 instance SuppressUnusedWarnings (:*:@#@$) where suppressUnusedWarnings = snd ((,) (::*:@#@$###) ()) - infixl 6 :*:@#@$ + 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 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 + type Compare a a = Compare_0123456789876543210 a a + type ShowsPrec_0123456789876543210 :: forall a. GHC.Internal.Bignum.Natural.Natural + -> T a () -> Symbol -> Symbol + type family ShowsPrec_0123456789876543210 @a (a :: GHC.Internal.Bignum.Natural.Natural) (a :: T a ()) (a :: Symbol) :: Symbol where + ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) ((:*:) argL_0123456789876543210 argR_0123456789876543210 :: T a ()) (a_0123456789876543210 :: Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 6))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 7)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " :*: ")) (Apply (Apply ShowsPrecSym0 (FromInteger 7)) argR_0123456789876543210)))) a_0123456789876543210 instance PShow (T a ()) where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a type TFHelper_0123456789876543210 :: S -> S -> Bool type family TFHelper_0123456789876543210 (a :: S) (a :: S) :: Bool where TFHelper_0123456789876543210 S1 S1 = TrueSym0 TFHelper_0123456789876543210 S1 S2 = FalseSym0 TFHelper_0123456789876543210 S2 S1 = FalseSym0 TFHelper_0123456789876543210 S2 S2 = TrueSym0 - type TFHelper_0123456789876543210Sym0 :: (~>) S ((~>) S Bool) - data TFHelper_0123456789876543210Sym0 :: (~>) S ((~>) S Bool) - where - TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) => - TFHelper_0123456789876543210Sym0 a0123456789876543210 - type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) TFHelper_0123456789876543210Sym0KindInference ()) - type TFHelper_0123456789876543210Sym1 :: S -> (~>) S Bool - data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: S) :: (~>) S Bool - where - TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) => - TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) TFHelper_0123456789876543210Sym1KindInference ()) - type TFHelper_0123456789876543210Sym2 :: S -> S -> Bool - type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: S) (a0123456789876543210 :: S) :: Bool where - TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 instance PEq S where - type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a + type (==) a a = TFHelper_0123456789876543210 a a type Compare_0123456789876543210 :: S -> S -> Ordering type family Compare_0123456789876543210 (a :: S) (a :: S) :: Ordering where Compare_0123456789876543210 S1 S1 = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0 Compare_0123456789876543210 S2 S2 = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0 Compare_0123456789876543210 S1 S2 = LTSym0 Compare_0123456789876543210 S2 S1 = GTSym0 - type Compare_0123456789876543210Sym0 :: (~>) S ((~>) S Ordering) - data Compare_0123456789876543210Sym0 :: (~>) S ((~>) S Ordering) - where - Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) => - Compare_0123456789876543210Sym0 a0123456789876543210 - type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) Compare_0123456789876543210Sym0KindInference ()) - type Compare_0123456789876543210Sym1 :: S -> (~>) S Ordering - data Compare_0123456789876543210Sym1 (a0123456789876543210 :: S) :: (~>) S Ordering - where - Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) => - Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) Compare_0123456789876543210Sym1KindInference ()) - type Compare_0123456789876543210Sym2 :: S -> S -> Ordering - type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: S) (a0123456789876543210 :: S) :: Ordering where - Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210 instance POrd S where - type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a - type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural + type Compare a a = Compare_0123456789876543210 a a + type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural -> S -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: S) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: S) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 _ S1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "S1") a_0123456789876543210 ShowsPrec_0123456789876543210 _ S2 a_0123456789876543210 = Apply (Apply ShowStringSym0 "S2") a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) S ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) S ((~>) Symbol Symbol)) - where - ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => - ShowsPrec_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym0KindInference ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural - -> (~>) S ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) S ((~>) Symbol Symbol) - where - ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym1KindInference ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural - -> S -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: S) :: (~>) Symbol Symbol - where - ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym2KindInference ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural - -> S -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: S) (a0123456789876543210 :: Symbol) :: Symbol where - ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow S where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a type MinBound_0123456789876543210 :: S type family MinBound_0123456789876543210 :: S where MinBound_0123456789876543210 = S1Sym0 - type MinBound_0123456789876543210Sym0 :: S - type family MinBound_0123456789876543210Sym0 :: S where - MinBound_0123456789876543210Sym0 = MinBound_0123456789876543210 type MaxBound_0123456789876543210 :: S type family MaxBound_0123456789876543210 :: S where MaxBound_0123456789876543210 = S2Sym0 - type MaxBound_0123456789876543210Sym0 :: S - type family MaxBound_0123456789876543210Sym0 :: S where - MaxBound_0123456789876543210Sym0 = MaxBound_0123456789876543210 instance PBounded S where - type MinBound = MinBound_0123456789876543210Sym0 - type MaxBound = MaxBound_0123456789876543210Sym0 - type family Case_0123456789876543210 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.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 n 'True = S2Sym0 + LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument" + data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where - ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) => - ToEnum_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) => + LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where suppressUnusedWarnings - = snd ((,) ToEnum_0123456789876543210Sym0KindInference ()) - type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> S - type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: S where - ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - type FromEnum_0123456789876543210 :: S -> GHC.Num.Natural.Natural - type family FromEnum_0123456789876543210 (a :: S) :: GHC.Num.Natural.Natural where - FromEnum_0123456789876543210 S1 = FromInteger 0 - FromEnum_0123456789876543210 S2 = FromInteger 1 - type FromEnum_0123456789876543210Sym0 :: (~>) S GHC.Num.Natural.Natural - data FromEnum_0123456789876543210Sym0 :: (~>) S GHC.Num.Natural.Natural + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 n 'True = S1Sym0 + LamCases_0123456789876543210 n 'False = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 1)) + data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where - FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) => - FromEnum_0123456789876543210Sym0 a0123456789876543210 - type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) => + LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where suppressUnusedWarnings - = snd ((,) FromEnum_0123456789876543210Sym0KindInference ()) - type FromEnum_0123456789876543210Sym1 :: S - -> GHC.Num.Natural.Natural - type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: S) :: GHC.Num.Natural.Natural where - FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural + -> S + type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: S where + ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0)) + type FromEnum_0123456789876543210 :: S + -> GHC.Internal.Bignum.Natural.Natural + type family FromEnum_0123456789876543210 (a :: S) :: GHC.Internal.Bignum.Natural.Natural where + FromEnum_0123456789876543210 S1 = FromInteger 0 + FromEnum_0123456789876543210 S2 = FromInteger 1 instance PEnum S where - type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a - type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a - infixl 6 :%*: + type ToEnum a = ToEnum_0123456789876543210 a + type FromEnum a = FromEnum_0123456789876543210 a + infixl 6 data :%*: data ST :: forall a b. T a b -> Type where (:%*:) :: forall a b (n :: a) (n :: b). @@ -311,8 +151,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 +165,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 +180,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 +203,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 +235,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 +255,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 +272,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 +320,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 diff --git a/tests/compile-and-dump/Singletons/Star.golden b/tests/compile-and-dump/Singletons/Star.golden --- a/tests/compile-and-dump/Singletons/Star.golden +++ b/tests/compile-and-dump/Singletons/Star.golden @@ -23,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,72 +104,18 @@ Compare_0123456789876543210 (Vec _ _) Int = GTSym0 Compare_0123456789876543210 (Vec _ _) String = GTSym0 Compare_0123456789876543210 (Vec _ _) (Maybe _) = GTSym0 - type Compare_0123456789876543210Sym0 :: (~>) Type ((~>) Type Ordering) - data Compare_0123456789876543210Sym0 :: (~>) Type ((~>) Type Ordering) - where - Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) => - Compare_0123456789876543210Sym0 a0123456789876543210 - type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) Compare_0123456789876543210Sym0KindInference ()) - type Compare_0123456789876543210Sym1 :: Type -> (~>) Type Ordering - data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Type) :: (~>) Type Ordering - where - Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) => - Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) Compare_0123456789876543210Sym1KindInference ()) - type Compare_0123456789876543210Sym2 :: Type -> Type -> Ordering - type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: Type) (a0123456789876543210 :: Type) :: Ordering where - Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210 instance POrd Type where - type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a - type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural + type Compare a a = Compare_0123456789876543210 a a + type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural -> Type -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Type) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Type) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 _ Nat a_0123456789876543210 = Apply (Apply ShowStringSym0 "Nat") a_0123456789876543210 ShowsPrec_0123456789876543210 _ Int a_0123456789876543210 = Apply (Apply ShowStringSym0 "Int") a_0123456789876543210 ShowsPrec_0123456789876543210 _ String a_0123456789876543210 = Apply (Apply ShowStringSym0 "String") a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 (Maybe arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Maybe ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 (Vec arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Vec ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Type ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Type ((~>) Symbol Symbol)) - where - ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => - ShowsPrec_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym0KindInference ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural - -> (~>) Type ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Type ((~>) Symbol Symbol) - where - ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym1KindInference ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural - -> Type -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Type) :: (~>) Symbol Symbol - where - ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym2KindInference ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural - -> Type -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Type) (a0123456789876543210 :: Symbol) :: Symbol where - ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow Type where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a data SRep :: Type -> Type where SNat :: SRep (Nat :: Type) @@ -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 diff --git a/tests/compile-and-dump/Singletons/T124.golden b/tests/compile-and-dump/Singletons/T124.golden --- a/tests/compile-and-dump/Singletons/T124.golden +++ b/tests/compile-and-dump/Singletons/T124.golden @@ -12,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 diff --git a/tests/compile-and-dump/Singletons/T136.golden b/tests/compile-and-dump/Singletons/T136.golden --- a/tests/compile-and-dump/Singletons/T136.golden +++ b/tests/compile-and-dump/Singletons/T136.golden @@ -34,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.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 i arg_0123456789876543210 'True = NilSym0 + LamCases_0123456789876543210 i arg_0123456789876543210 'False = Apply SuccSym0 (Apply ToEnumSym0 (Apply PredSym0 i)) + data LamCases_0123456789876543210Sym0 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where - Pred_0123456789876543210Sym0KindInference :: SameKind (Apply Pred_0123456789876543210Sym0 arg) (Pred_0123456789876543210Sym1 arg) => - Pred_0123456789876543210Sym0 a0123456789876543210 - type instance Apply Pred_0123456789876543210Sym0 a0123456789876543210 = Pred_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings Pred_0123456789876543210Sym0 where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 i0123456789876543210 arg_01234567898765432100123456789876543210 arg) => + LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) where suppressUnusedWarnings - = snd ((,) Pred_0123456789876543210Sym0KindInference ()) - type Pred_0123456789876543210Sym1 :: [Bool] -> [Bool] - type family Pred_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) :: [Bool] where - Pred_0123456789876543210Sym1 a0123456789876543210 = Pred_0123456789876543210 a0123456789876543210 - type family Case_0123456789876543210 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)) - type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural - -> [Bool] - type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: [Bool] where - ToEnum_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210 - type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural [Bool] - data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural [Bool] + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + type family LamCases_0123456789876543210 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 i arg_0123456789876543210 'True = Apply ErrorSym0 "negative toEnum" + LamCases_0123456789876543210 i arg_0123456789876543210 'False = Apply (LamCases_0123456789876543210Sym0 i arg_0123456789876543210) (Apply (Apply (==@#@$) i) (FromInteger 0)) + data LamCases_0123456789876543210Sym0 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where - ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) => - ToEnum_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 i0123456789876543210 arg_01234567898765432100123456789876543210 arg) => + LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 i0123456789876543210 arg_01234567898765432100123456789876543210) where suppressUnusedWarnings - = snd ((,) ToEnum_0123456789876543210Sym0KindInference ()) - type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural - -> [Bool] - type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: [Bool] where - ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 i0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 i0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + type family LamCases_0123456789876543210 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 arg_0123456789876543210 i = Apply (LamCases_0123456789876543210Sym0 i arg_0123456789876543210) (Apply (Apply (<@#@$) i) (FromInteger 0)) + data LamCases_0123456789876543210Sym0 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 + where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 arg_01234567898765432100123456789876543210) arg) (LamCases_0123456789876543210Sym1 arg_01234567898765432100123456789876543210 arg) => + LamCases_0123456789876543210Sym0 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 arg_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 arg_01234567898765432100123456789876543210) where + suppressUnusedWarnings + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 (arg_01234567898765432100123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 arg_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 + type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural + -> [Bool] + type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: [Bool] where + ToEnum_0123456789876543210 arg_0123456789876543210 = Apply (LamCases_0123456789876543210Sym0 arg_0123456789876543210) arg_0123456789876543210 type FromEnum_0123456789876543210 :: [Bool] - -> GHC.Num.Natural.Natural - type family FromEnum_0123456789876543210 (a :: [Bool]) :: GHC.Num.Natural.Natural where + -> GHC.Internal.Bignum.Natural.Natural + type family FromEnum_0123456789876543210 (a :: [Bool]) :: GHC.Internal.Bignum.Natural.Natural where FromEnum_0123456789876543210 '[] = FromInteger 0 FromEnum_0123456789876543210 ('(:) 'False as) = Apply (Apply (*@#@$) (FromInteger 2)) (Apply FromEnumSym0 as) FromEnum_0123456789876543210 ('(:) 'True as) = Apply (Apply (+@#@$) (FromInteger 1)) (Apply (Apply (*@#@$) (FromInteger 2)) (Apply FromEnumSym0 as)) - type FromEnum_0123456789876543210Sym0 :: (~>) [Bool] GHC.Num.Natural.Natural - data FromEnum_0123456789876543210Sym0 :: (~>) [Bool] GHC.Num.Natural.Natural - where - FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) => - FromEnum_0123456789876543210Sym0 a0123456789876543210 - type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) FromEnum_0123456789876543210Sym0KindInference ()) - type FromEnum_0123456789876543210Sym1 :: [Bool] - -> GHC.Num.Natural.Natural - type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) :: GHC.Num.Natural.Natural where - FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 instance PEnum [Bool] where - type Succ a = Apply Succ_0123456789876543210Sym0 a - type Pred a = Apply Pred_0123456789876543210Sym0 a - type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a - type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a + type Succ a = Succ_0123456789876543210 a + type Pred a = Pred_0123456789876543210 a + type ToEnum a = ToEnum_0123456789876543210 a + type FromEnum a = FromEnum_0123456789876543210 a instance SEnum [Bool] where - sSucc :: - forall (t :: [Bool]). Sing t - -> Sing (Apply (SuccSym0 :: TyFun [Bool] [Bool] -> Type) t) - sPred :: - forall (t :: [Bool]). Sing t - -> Sing (Apply (PredSym0 :: TyFun [Bool] [Bool] -> Type) t) - sToEnum :: - forall (t :: GHC.Num.Natural.Natural). Sing t - -> Sing (Apply (ToEnumSym0 :: TyFun GHC.Num.Natural.Natural [Bool] - -> Type) t) - sFromEnum :: - forall (t :: [Bool]). Sing t - -> Sing (Apply (FromEnumSym0 :: TyFun [Bool] GHC.Num.Natural.Natural - -> Type) t) sSucc SNil = applySing (applySing (singFun2 @(:@#@$) SCons) STrue) SNil 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 diff --git a/tests/compile-and-dump/Singletons/T136b.golden b/tests/compile-and-dump/Singletons/T136b.golden --- a/tests/compile-and-dump/Singletons/T136b.golden +++ b/tests/compile-and-dump/Singletons/T136b.golden @@ -10,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 diff --git a/tests/compile-and-dump/Singletons/T145.golden b/tests/compile-and-dump/Singletons/T145.golden --- a/tests/compile-and-dump/Singletons/T145.golden +++ b/tests/compile-and-dump/Singletons/T145.golden @@ -10,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 diff --git a/tests/compile-and-dump/Singletons/T150.golden b/tests/compile-and-dump/Singletons/T150.golden --- a/tests/compile-and-dump/Singletons/T150.golden +++ b/tests/compile-and-dump/Singletons/T150.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T159.golden b/tests/compile-and-dump/Singletons/T159.golden --- a/tests/compile-and-dump/Singletons/T159.golden +++ b/tests/compile-and-dump/Singletons/T159.golden @@ -63,45 +63,45 @@ where C1Sym0KindInference :: SameKind (Apply C1Sym0 arg) (C1Sym1 arg) => C1Sym0 a0123456789876543210 - type instance Apply C1Sym0 a0123456789876543210 = C1Sym1 a0123456789876543210 + type instance Apply @T0 @((~>) T1 T1) C1Sym0 a0123456789876543210 = C1Sym1 a0123456789876543210 instance SuppressUnusedWarnings C1Sym0 where suppressUnusedWarnings = snd ((,) C1Sym0KindInference ()) - infixr 5 `C1Sym0` + 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 diff --git a/tests/compile-and-dump/Singletons/T160.golden b/tests/compile-and-dump/Singletons/T160.golden --- a/tests/compile-and-dump/Singletons/T160.golden +++ b/tests/compile-and-dump/Singletons/T160.golden @@ -5,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] diff --git a/tests/compile-and-dump/Singletons/T163.golden b/tests/compile-and-dump/Singletons/T163.golden --- a/tests/compile-and-dump/Singletons/T163.golden +++ b/tests/compile-and-dump/Singletons/T163.golden @@ -7,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 diff --git a/tests/compile-and-dump/Singletons/T166.golden b/tests/compile-and-dump/Singletons/T166.golden --- a/tests/compile-and-dump/Singletons/T166.golden +++ b/tests/compile-and-dump/Singletons/T166.golden @@ -10,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| diff --git a/tests/compile-and-dump/Singletons/T167.golden b/tests/compile-and-dump/Singletons/T167.golden --- a/tests/compile-and-dump/Singletons/T167.golden +++ b/tests/compile-and-dump/Singletons/T167.golden @@ -13,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) diff --git a/tests/compile-and-dump/Singletons/T172.golden b/tests/compile-and-dump/Singletons/T172.golden --- a/tests/compile-and-dump/Singletons/T172.golden +++ b/tests/compile-and-dump/Singletons/T172.golden @@ -8,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) diff --git a/tests/compile-and-dump/Singletons/T175.golden b/tests/compile-and-dump/Singletons/T175.golden --- a/tests/compile-and-dump/Singletons/T175.golden +++ b/tests/compile-and-dump/Singletons/T175.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T176.golden b/tests/compile-and-dump/Singletons/T176.golden --- a/tests/compile-and-dump/Singletons/T176.golden +++ b/tests/compile-and-dump/Singletons/T176.golden @@ -22,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 diff --git a/tests/compile-and-dump/Singletons/T178.golden b/tests/compile-and-dump/Singletons/T178.golden --- a/tests/compile-and-dump/Singletons/T178.golden +++ b/tests/compile-and-dump/Singletons/T178.golden @@ -42,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 diff --git a/tests/compile-and-dump/Singletons/T183.golden b/tests/compile-and-dump/Singletons/T183.golden --- a/tests/compile-and-dump/Singletons/T183.golden +++ b/tests/compile-and-dump/Singletons/T183.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T184.golden b/tests/compile-and-dump/Singletons/T184.golden --- a/tests/compile-and-dump/Singletons/T184.golden +++ b/tests/compile-and-dump/Singletons/T184.golden @@ -25,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 diff --git a/tests/compile-and-dump/Singletons/T187.golden b/tests/compile-and-dump/Singletons/T187.golden --- a/tests/compile-and-dump/Singletons/T187.golden +++ b/tests/compile-and-dump/Singletons/T187.golden @@ -11,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 diff --git a/tests/compile-and-dump/Singletons/T190.golden b/tests/compile-and-dump/Singletons/T190.golden --- a/tests/compile-and-dump/Singletons/T190.golden +++ b/tests/compile-and-dump/Singletons/T190.golden @@ -13,146 +13,54 @@ type TFHelper_0123456789876543210 :: T -> T -> Bool type family TFHelper_0123456789876543210 (a :: T) (a :: T) :: Bool where TFHelper_0123456789876543210 T T = TrueSym0 - type TFHelper_0123456789876543210Sym0 :: (~>) T ((~>) T Bool) - data TFHelper_0123456789876543210Sym0 :: (~>) T ((~>) T Bool) - where - TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) => - TFHelper_0123456789876543210Sym0 a0123456789876543210 - type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) TFHelper_0123456789876543210Sym0KindInference ()) - type TFHelper_0123456789876543210Sym1 :: T -> (~>) T Bool - data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: T) :: (~>) T Bool - where - TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) => - TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) TFHelper_0123456789876543210Sym1KindInference ()) - type TFHelper_0123456789876543210Sym2 :: T -> T -> Bool - type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: T) (a0123456789876543210 :: T) :: Bool where - TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 instance PEq T where - type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a + type (==) a a = TFHelper_0123456789876543210 a a type Compare_0123456789876543210 :: T -> T -> Ordering type family Compare_0123456789876543210 (a :: T) (a :: T) :: Ordering where Compare_0123456789876543210 T T = Apply (Apply (Apply FoldlSym0 (<>@#@$)) EQSym0) NilSym0 - type Compare_0123456789876543210Sym0 :: (~>) T ((~>) T Ordering) - data Compare_0123456789876543210Sym0 :: (~>) T ((~>) T Ordering) - where - Compare_0123456789876543210Sym0KindInference :: SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) => - Compare_0123456789876543210Sym0 a0123456789876543210 - type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings Compare_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) Compare_0123456789876543210Sym0KindInference ()) - type Compare_0123456789876543210Sym1 :: T -> (~>) T Ordering - data Compare_0123456789876543210Sym1 (a0123456789876543210 :: T) :: (~>) T Ordering - where - Compare_0123456789876543210Sym1KindInference :: SameKind (Apply (Compare_0123456789876543210Sym1 a0123456789876543210) arg) (Compare_0123456789876543210Sym2 a0123456789876543210 arg) => - Compare_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (Compare_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) Compare_0123456789876543210Sym1KindInference ()) - type Compare_0123456789876543210Sym2 :: T -> T -> Ordering - type family Compare_0123456789876543210Sym2 (a0123456789876543210 :: T) (a0123456789876543210 :: T) :: Ordering where - Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210 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" - type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> T - type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: T where - ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)) - type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural T - data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural T + type Compare a a = Compare_0123456789876543210 a a + type family LamCases_0123456789876543210 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 n 'True = TSym0 + LamCases_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument" + data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where - ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) => - ToEnum_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) => + LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where suppressUnusedWarnings - = snd ((,) ToEnum_0123456789876543210Sym0KindInference ()) - type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> T - type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: T where - ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - type FromEnum_0123456789876543210 :: T -> GHC.Num.Natural.Natural - type family FromEnum_0123456789876543210 (a :: T) :: GHC.Num.Natural.Natural where + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural + -> T + type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: T where + ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0)) + type FromEnum_0123456789876543210 :: T + -> GHC.Internal.Bignum.Natural.Natural + type family FromEnum_0123456789876543210 (a :: T) :: GHC.Internal.Bignum.Natural.Natural where FromEnum_0123456789876543210 T = FromInteger 0 - type FromEnum_0123456789876543210Sym0 :: (~>) T GHC.Num.Natural.Natural - data FromEnum_0123456789876543210Sym0 :: (~>) T GHC.Num.Natural.Natural - where - FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) => - FromEnum_0123456789876543210Sym0 a0123456789876543210 - type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) FromEnum_0123456789876543210Sym0KindInference ()) - type FromEnum_0123456789876543210Sym1 :: T - -> GHC.Num.Natural.Natural - type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: T) :: GHC.Num.Natural.Natural where - FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 instance PEnum T where - type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a - type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a + type ToEnum a = ToEnum_0123456789876543210 a + type FromEnum a = FromEnum_0123456789876543210 a type MinBound_0123456789876543210 :: T type family MinBound_0123456789876543210 :: T where MinBound_0123456789876543210 = TSym0 - type MinBound_0123456789876543210Sym0 :: T - type family MinBound_0123456789876543210Sym0 :: T where - MinBound_0123456789876543210Sym0 = MinBound_0123456789876543210 type MaxBound_0123456789876543210 :: T type family MaxBound_0123456789876543210 :: T where MaxBound_0123456789876543210 = TSym0 - type MaxBound_0123456789876543210Sym0 :: T - type family MaxBound_0123456789876543210Sym0 :: T where - MaxBound_0123456789876543210Sym0 = MaxBound_0123456789876543210 instance PBounded T where - type MinBound = MinBound_0123456789876543210Sym0 - type MaxBound = MaxBound_0123456789876543210Sym0 - type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural - -> T -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: T) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type MinBound = MinBound_0123456789876543210 + type MaxBound = MaxBound_0123456789876543210 + type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural + -> T + -> GHC.Internal.Types.Symbol + -> GHC.Internal.Types.Symbol + type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: T) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where ShowsPrec_0123456789876543210 _ T a_0123456789876543210 = Apply (Apply ShowStringSym0 "T") a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - where - ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => - ShowsPrec_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym0KindInference ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural - -> (~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol) - where - ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym1KindInference ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural - -> T -> (~>) GHC.Types.Symbol GHC.Types.Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: T) :: (~>) GHC.Types.Symbol GHC.Types.Symbol - where - ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where - suppressUnusedWarnings - = snd ((,) ShowsPrec_0123456789876543210Sym2KindInference ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural - -> T -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: T) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where - ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow T where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a data ST :: T -> Type where ST :: ST (T :: T) type instance Sing @T = ST instance SingKind T where @@ -160,18 +68,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 +77,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 diff --git a/tests/compile-and-dump/Singletons/T197.golden b/tests/compile-and-dump/Singletons/T197.golden --- a/tests/compile-and-dump/Singletons/T197.golden +++ b/tests/compile-and-dump/Singletons/T197.golden @@ -13,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 @($$:@#@$) (%$$:) diff --git a/tests/compile-and-dump/Singletons/T197b.golden b/tests/compile-and-dump/Singletons/T197b.golden --- a/tests/compile-and-dump/Singletons/T197b.golden +++ b/tests/compile-and-dump/Singletons/T197b.golden @@ -14,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 diff --git a/tests/compile-and-dump/Singletons/T200.golden b/tests/compile-and-dump/Singletons/T200.golden --- a/tests/compile-and-dump/Singletons/T200.golden +++ b/tests/compile-and-dump/Singletons/T200.golden @@ -23,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 diff --git a/tests/compile-and-dump/Singletons/T204.golden b/tests/compile-and-dump/Singletons/T204.golden --- a/tests/compile-and-dump/Singletons/T204.golden +++ b/tests/compile-and-dump/Singletons/T204.golden @@ -20,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,13 +47,13 @@ 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 type family (:%%@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ratio2 a where (:%%@#@$$$) a0123456789876543210 a0123456789876543210 = (:%%) a0123456789876543210 a0123456789876543210 - data SRatio1 :: forall a. Ratio1 a -> GHC.Types.Type + data SRatio1 :: forall a. Ratio1 a -> GHC.Internal.Types.Type where (:^%) :: forall a (n :: a) (n :: a). (Sing n) -> (Sing n) -> SRatio1 ((:%) n n :: Ratio1 a) @@ -62,9 +62,9 @@ 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) - data SRatio2 :: forall a. Ratio2 a -> GHC.Types.Type + = (\cases (SomeSing c) (SomeSing c) -> SomeSing ((:^%) c c)) + (toSing b :: SomeSing a) (toSing b :: SomeSing a) + data SRatio2 :: forall a. Ratio2 a -> GHC.Internal.Types.Type where (:^%%) :: forall a (n :: a) (n :: a). (Sing n) -> (Sing n) -> SRatio2 ((:%%) n n :: Ratio2 a) @@ -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 diff --git a/tests/compile-and-dump/Singletons/T209.golden b/tests/compile-and-dump/Singletons/T209.golden --- a/tests/compile-and-dump/Singletons/T209.golden +++ b/tests/compile-and-dump/Singletons/T209.golden @@ -25,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 diff --git a/tests/compile-and-dump/Singletons/T209.hs b/tests/compile-and-dump/Singletons/T209.hs --- a/tests/compile-and-dump/Singletons/T209.hs +++ b/tests/compile-and-dump/Singletons/T209.hs @@ -1,5 +1,4 @@ {-# LANGUAGE DeriveAnyClass #-} -{-# LANGUAGE DerivingStrategies #-} module T209 where diff --git a/tests/compile-and-dump/Singletons/T216.golden b/tests/compile-and-dump/Singletons/T216.golden --- a/tests/compile-and-dump/Singletons/T216.golden +++ b/tests/compile-and-dump/Singletons/T216.golden @@ -5,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 diff --git a/tests/compile-and-dump/Singletons/T229.golden b/tests/compile-and-dump/Singletons/T229.golden --- a/tests/compile-and-dump/Singletons/T229.golden +++ b/tests/compile-and-dump/Singletons/T229.golden @@ -10,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 diff --git a/tests/compile-and-dump/Singletons/T249.golden b/tests/compile-and-dump/Singletons/T249.golden --- a/tests/compile-and-dump/Singletons/T249.golden +++ b/tests/compile-and-dump/Singletons/T249.golden @@ -12,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 diff --git a/tests/compile-and-dump/Singletons/T271.golden b/tests/compile-and-dump/Singletons/T271.golden --- a/tests/compile-and-dump/Singletons/T271.golden +++ b/tests/compile-and-dump/Singletons/T271.golden @@ -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 => diff --git a/tests/compile-and-dump/Singletons/T287.golden b/tests/compile-and-dump/Singletons/T287.golden --- a/tests/compile-and-dump/Singletons/T287.golden +++ b/tests/compile-and-dump/Singletons/T287.golden @@ -15,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) => diff --git a/tests/compile-and-dump/Singletons/T29.golden b/tests/compile-and-dump/Singletons/T29.golden --- a/tests/compile-and-dump/Singletons/T29.golden +++ b/tests/compile-and-dump/Singletons/T29.golden @@ -22,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 diff --git a/tests/compile-and-dump/Singletons/T296.golden b/tests/compile-and-dump/Singletons/T296.golden --- a/tests/compile-and-dump/Singletons/T296.golden +++ b/tests/compile-and-dump/Singletons/T296.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T297.golden b/tests/compile-and-dump/Singletons/T297.golden --- a/tests/compile-and-dump/Singletons/T297.golden +++ b/tests/compile-and-dump/Singletons/T297.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T312.golden b/tests/compile-and-dump/Singletons/T312.golden --- a/tests/compile-and-dump/Singletons/T312.golden +++ b/tests/compile-and-dump/Singletons/T312.golden @@ -24,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 diff --git a/tests/compile-and-dump/Singletons/T313.golden b/tests/compile-and-dump/Singletons/T313.golden --- a/tests/compile-and-dump/Singletons/T313.golden +++ b/tests/compile-and-dump/Singletons/T313.golden @@ -8,9 +8,9 @@ type PFoo4 a type PFoo4 a = Maybe a - type instance PFoo2 a = Maybe a instance PC a where - type PFoo4 a = Maybe a |] + type PFoo4 a = Maybe a + type instance PFoo2 a = Maybe a |] ======> type PFoo1 a = Maybe a type family PFoo2 a @@ -26,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 @@ -70,9 +70,9 @@ type SFoo4 a type SFoo4 a = Maybe a - type instance SFoo2 a = Maybe a instance SC a where - type SFoo4 a = Maybe a |] + type SFoo4 a = Maybe a + type instance SFoo2 a = Maybe a |] ======> type SFoo1 a = Maybe a type family SFoo2 a @@ -88,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 diff --git a/tests/compile-and-dump/Singletons/T316.golden b/tests/compile-and-dump/Singletons/T316.golden --- a/tests/compile-and-dump/Singletons/T316.golden +++ b/tests/compile-and-dump/Singletons/T316.golden @@ -8,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 ()) diff --git a/tests/compile-and-dump/Singletons/T322.golden b/tests/compile-and-dump/Singletons/T322.golden --- a/tests/compile-and-dump/Singletons/T322.golden +++ b/tests/compile-and-dump/Singletons/T322.golden @@ -13,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) diff --git a/tests/compile-and-dump/Singletons/T326.golden b/tests/compile-and-dump/Singletons/T326.golden --- a/tests/compile-and-dump/Singletons/T326.golden +++ b/tests/compile-and-dump/Singletons/T326.golden @@ -1,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) => diff --git a/tests/compile-and-dump/Singletons/T33.golden b/tests/compile-and-dump/Singletons/T33.golden --- a/tests/compile-and-dump/Singletons/T33.golden +++ b/tests/compile-and-dump/Singletons/T33.golden @@ -10,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| | ^^^^^^^^^^^^^^^... + diff --git a/tests/compile-and-dump/Singletons/T332.golden b/tests/compile-and-dump/Singletons/T332.golden --- a/tests/compile-and-dump/Singletons/T332.golden +++ b/tests/compile-and-dump/Singletons/T332.golden @@ -16,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 diff --git a/tests/compile-and-dump/Singletons/T342.golden b/tests/compile-and-dump/Singletons/T342.golden --- a/tests/compile-and-dump/Singletons/T342.golden +++ b/tests/compile-and-dump/Singletons/T342.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T353.golden b/tests/compile-and-dump/Singletons/T353.golden --- a/tests/compile-and-dump/Singletons/T353.golden +++ b/tests/compile-and-dump/Singletons/T353.golden @@ -11,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 diff --git a/tests/compile-and-dump/Singletons/T358.golden b/tests/compile-and-dump/Singletons/T358.golden --- a/tests/compile-and-dump/Singletons/T358.golden +++ b/tests/compile-and-dump/Singletons/T358.golden @@ -5,13 +5,13 @@ class C2 a where method2a, method2b :: forall b. b -> a - instance C1 [] where - method1 :: [a] - method1 = [] instance C2 [a] where method2a _ = [] method2b :: forall b. b -> [a] - method2b _ = [] |] + method2b _ = [] + instance C1 [] where + method1 :: [a] + method1 = [] |] ======> class C1 (f :: k -> Type) where method1 :: f a @@ -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 diff --git a/tests/compile-and-dump/Singletons/T367.golden b/tests/compile-and-dump/Singletons/T367.golden --- a/tests/compile-and-dump/Singletons/T367.golden +++ b/tests/compile-and-dump/Singletons/T367.golden @@ -8,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' diff --git a/tests/compile-and-dump/Singletons/T371.golden b/tests/compile-and-dump/Singletons/T371.golden --- a/tests/compile-and-dump/Singletons/T371.golden +++ b/tests/compile-and-dump/Singletons/T371.golden @@ -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,30 @@ 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 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 + type ShowsPrec_0123456789876543210 :: forall a. GHC.Internal.Bignum.Natural.Natural + -> X a + -> GHC.Internal.Types.Symbol + -> GHC.Internal.Types.Symbol + type family ShowsPrec_0123456789876543210 @a (a :: GHC.Internal.Bignum.Natural.Natural) (a :: X a) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where + ShowsPrec_0123456789876543210 @a (_ :: GHC.Internal.Bignum.Natural.Natural) (X1 :: X a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply ShowStringSym0 "X1") a_0123456789876543210 + ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (X2 arg_0123456789876543210 :: X a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "X2 ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210 instance PShow (X a) where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a - type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural - -> Y a -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210 @a (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 + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a + type ShowsPrec_0123456789876543210 :: forall a. GHC.Internal.Bignum.Natural.Natural + -> Y a + -> GHC.Internal.Types.Symbol + -> GHC.Internal.Types.Symbol + type family ShowsPrec_0123456789876543210 @a (a :: GHC.Internal.Bignum.Natural.Natural) (a :: Y a) (a :: GHC.Internal.Types.Symbol) :: GHC.Internal.Types.Symbol where + ShowsPrec_0123456789876543210 @a (_ :: GHC.Internal.Bignum.Natural.Natural) (Y1 :: Y a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply ShowStringSym0 "Y1") a_0123456789876543210 + ShowsPrec_0123456789876543210 @a (p_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) (Y2 arg_0123456789876543210 :: Y a) (a_0123456789876543210 :: GHC.Internal.Types.Symbol) = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Y2 ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210 instance PShow (Y a) where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a + type ShowsPrec a a a = ShowsPrec_0123456789876543210 a a a data SX :: forall (a :: Type). X a -> Type where SX1 :: forall (a :: Type). SX (X1 :: X a) @@ -132,7 +70,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 +83,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 +117,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 diff --git a/tests/compile-and-dump/Singletons/T376.golden b/tests/compile-and-dump/Singletons/T376.golden --- a/tests/compile-and-dump/Singletons/T376.golden +++ b/tests/compile-and-dump/Singletons/T376.golden @@ -10,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) diff --git a/tests/compile-and-dump/Singletons/T378a.golden b/tests/compile-and-dump/Singletons/T378a.golden --- a/tests/compile-and-dump/Singletons/T378a.golden +++ b/tests/compile-and-dump/Singletons/T378a.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T378b.golden b/tests/compile-and-dump/Singletons/T378b.golden --- a/tests/compile-and-dump/Singletons/T378b.golden +++ b/tests/compile-and-dump/Singletons/T378b.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T402.golden b/tests/compile-and-dump/Singletons/T402.golden --- a/tests/compile-and-dump/Singletons/T402.golden +++ b/tests/compile-and-dump/Singletons/T402.golden @@ -6,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 diff --git a/tests/compile-and-dump/Singletons/T410.golden b/tests/compile-and-dump/Singletons/T410.golden --- a/tests/compile-and-dump/Singletons/T410.golden +++ b/tests/compile-and-dump/Singletons/T410.golden @@ -15,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 diff --git a/tests/compile-and-dump/Singletons/T412.golden b/tests/compile-and-dump/Singletons/T412.golden --- a/tests/compile-and-dump/Singletons/T412.golden +++ b/tests/compile-and-dump/Singletons/T412.golden @@ -30,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 diff --git a/tests/compile-and-dump/Singletons/T414.golden b/tests/compile-and-dump/Singletons/T414.golden --- a/tests/compile-and-dump/Singletons/T414.golden +++ b/tests/compile-and-dump/Singletons/T414.golden @@ -20,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 diff --git a/tests/compile-and-dump/Singletons/T433.golden b/tests/compile-and-dump/Singletons/T433.golden --- a/tests/compile-and-dump/Singletons/T433.golden +++ b/tests/compile-and-dump/Singletons/T433.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T443.golden b/tests/compile-and-dump/Singletons/T443.golden --- a/tests/compile-and-dump/Singletons/T443.golden +++ b/tests/compile-and-dump/Singletons/T443.golden @@ -20,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 diff --git a/tests/compile-and-dump/Singletons/T445.golden b/tests/compile-and-dump/Singletons/T445.golden --- a/tests/compile-and-dump/Singletons/T445.golden +++ b/tests/compile-and-dump/Singletons/T445.golden @@ -6,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 diff --git a/tests/compile-and-dump/Singletons/T450.golden b/tests/compile-and-dump/Singletons/T450.golden --- a/tests/compile-and-dump/Singletons/T450.golden +++ b/tests/compile-and-dump/Singletons/T450.golden @@ -41,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 => diff --git a/tests/compile-and-dump/Singletons/T470.golden b/tests/compile-and-dump/Singletons/T470.golden --- a/tests/compile-and-dump/Singletons/T470.golden +++ b/tests/compile-and-dump/Singletons/T470.golden @@ -19,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 diff --git a/tests/compile-and-dump/Singletons/T487.golden b/tests/compile-and-dump/Singletons/T487.golden --- a/tests/compile-and-dump/Singletons/T487.golden +++ b/tests/compile-and-dump/Singletons/T487.golden @@ -25,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 diff --git a/tests/compile-and-dump/Singletons/T489.golden b/tests/compile-and-dump/Singletons/T489.golden --- a/tests/compile-and-dump/Singletons/T489.golden +++ b/tests/compile-and-dump/Singletons/T489.golden @@ -18,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)) diff --git a/tests/compile-and-dump/Singletons/T536.golden b/tests/compile-and-dump/Singletons/T536.golden --- a/tests/compile-and-dump/Singletons/T536.golden +++ b/tests/compile-and-dump/Singletons/T536.golden @@ -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 => diff --git a/tests/compile-and-dump/Singletons/T54.golden b/tests/compile-and-dump/Singletons/T54.golden --- a/tests/compile-and-dump/Singletons/T54.golden +++ b/tests/compile-and-dump/Singletons/T54.golden @@ -5,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 diff --git a/tests/compile-and-dump/Singletons/T555.golden b/tests/compile-and-dump/Singletons/T555.golden --- a/tests/compile-and-dump/Singletons/T555.golden +++ b/tests/compile-and-dump/Singletons/T555.golden @@ -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 ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural + type Compare a a = Compare_0123456789876543210 a a + type ShowsPrec_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural -> MyPropKind -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: MyPropKind) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) (a :: MyPropKind) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 _ Location a_0123456789876543210 = Apply (Apply ShowStringSym0 "Location") a_0123456789876543210 ShowsPrec_0123456789876543210 _ Quaternion a_0123456789876543210 = Apply (Apply ShowStringSym0 "Quaternion") a_0123456789876543210 - 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 diff --git a/tests/compile-and-dump/Singletons/T563.golden b/tests/compile-and-dump/Singletons/T563.golden --- a/tests/compile-and-dump/Singletons/T563.golden +++ b/tests/compile-and-dump/Singletons/T563.golden @@ -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| | ^^^^^^^^^^^^^^^^^^^... + diff --git a/tests/compile-and-dump/Singletons/T565.golden b/tests/compile-and-dump/Singletons/T565.golden new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T565.golden @@ -0,0 +1,16 @@ +Singletons/T565.hs:(0,0)-(0,0): Splicing declarations + singletons [d| data C a where D :: forall {a}. C a |] + ======> + data C a where D :: forall {a}. C a + type DSym0 :: forall {a}. C a + type family DSym0 :: C a where + DSym0 = D + data SC :: forall a. C a -> Type + where SD :: forall {a}. SC (D :: C a) + type instance Sing @(C a) = SC + instance SingKind a => SingKind (C a) where + type Demote (C a) = C (Demote a) + fromSing SD = D + toSing D = SomeSing SD + instance SingI D where + sing = SD diff --git a/tests/compile-and-dump/Singletons/T565.hs b/tests/compile-and-dump/Singletons/T565.hs new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T565.hs @@ -0,0 +1,8 @@ +module T565 where + +import Data.Singletons.TH + +$(singletons [d| + data C a where + D :: forall {a}. C a + |]) diff --git a/tests/compile-and-dump/Singletons/T567.golden b/tests/compile-and-dump/Singletons/T567.golden --- a/tests/compile-and-dump/Singletons/T567.golden +++ b/tests/compile-and-dump/Singletons/T567.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T571.golden b/tests/compile-and-dump/Singletons/T571.golden --- a/tests/compile-and-dump/Singletons/T571.golden +++ b/tests/compile-and-dump/Singletons/T571.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T581.golden b/tests/compile-and-dump/Singletons/T581.golden new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T581.golden @@ -0,0 +1,243 @@ +Singletons/T581.hs:(0,0)-(0,0): Splicing declarations + singletons + [d| class C1 a where + m1 :: forall b. a -> Maybe (a, b) + m1 _ = Nothing :: Maybe (a, b) + class C2 a where + m2 :: b -> Maybe a + m2 _ = Nothing :: Maybe a + class C3 a where + m3 :: forall b. a -> b -> (a, b) + m3 x y = (x, y) :: (a, b) + + instance C3 [a] where + m3 x y = (fmap (\ xx -> (xx :: a)) x, y) + instance C3 (Maybe a) where + m3 :: Maybe a -> b -> (Maybe a, b) + m3 x y = (fmap (\ xx -> (xx :: a)) x, y) + instance C2 (Maybe a) where + m2 _ = Nothing :: Maybe (Maybe a) + instance C2 [a] where + m2 :: b -> Maybe [a] + m2 _ = Nothing :: Maybe [a] + instance C1 [a] where + m1 :: forall b. [a] -> Maybe ([a], b) + m1 _ = Nothing :: Maybe ([a], b) |] + ======> + class C1 a where + m1 :: forall b. a -> Maybe (a, b) + m1 _ = Nothing :: Maybe (a, b) + instance C1 [a] where + m1 :: forall b. [a] -> Maybe ([a], b) + m1 _ = Nothing :: Maybe ([a], b) + class C2 a where + m2 :: b -> Maybe a + m2 _ = Nothing :: Maybe a + instance C2 [a] where + m2 :: b -> Maybe [a] + m2 _ = Nothing :: Maybe [a] + instance C2 (Maybe a) where + m2 _ = Nothing :: Maybe (Maybe a) + class C3 a where + m3 :: forall b. a -> b -> (a, b) + m3 x y = (x, y) :: (a, b) + instance C3 (Maybe a) where + m3 :: Maybe a -> b -> (Maybe a, b) + m3 x y = (fmap (\ xx -> xx :: a) x, y) + instance C3 [a] where + m3 x y = (fmap (\ xx -> xx :: a) x, y) + type M1Sym0 :: forall a b. (~>) a (Maybe (a, b)) + data M1Sym0 :: (~>) a (Maybe (a, b)) + where + M1Sym0KindInference :: SameKind (Apply M1Sym0 arg) (M1Sym1 arg) => + M1Sym0 a0123456789876543210 + type instance Apply @a @(Maybe (a, + b)) M1Sym0 a0123456789876543210 = M1 a0123456789876543210 + instance SuppressUnusedWarnings M1Sym0 where + suppressUnusedWarnings = snd ((,) M1Sym0KindInference ()) + type M1Sym1 :: forall a b. a -> Maybe (a, b) + type family M1Sym1 @a @b (a0123456789876543210 :: a) :: Maybe (a, + b) where + M1Sym1 a0123456789876543210 = M1 a0123456789876543210 + type M1_0123456789876543210 :: forall a b. a -> Maybe (a, b) + type family M1_0123456789876543210 @a @b (a :: a) :: Maybe (a, + b) where + M1_0123456789876543210 @a @b (_ :: a) = NothingSym0 :: Maybe (a, b) + class PC1 a where + type family M1 (arg :: a) :: Maybe (a, b) + type M1 a = M1_0123456789876543210 a + type M2Sym0 :: forall b a. (~>) b (Maybe a) + data M2Sym0 :: (~>) b (Maybe a) + where + M2Sym0KindInference :: SameKind (Apply M2Sym0 arg) (M2Sym1 arg) => + M2Sym0 a0123456789876543210 + type instance Apply @b @(Maybe a) M2Sym0 a0123456789876543210 = M2 a0123456789876543210 + instance SuppressUnusedWarnings M2Sym0 where + suppressUnusedWarnings = snd ((,) M2Sym0KindInference ()) + type M2Sym1 :: forall b a. b -> Maybe a + type family M2Sym1 @b @a (a0123456789876543210 :: b) :: Maybe a where + M2Sym1 a0123456789876543210 = M2 a0123456789876543210 + type M2_0123456789876543210 :: forall a b. b -> Maybe a + type family M2_0123456789876543210 @a @b (a :: b) :: Maybe a where + M2_0123456789876543210 @a @b (_ :: b) = NothingSym0 :: Maybe a + class PC2 a where + type family M2 (arg :: b) :: Maybe a + type M2 a = M2_0123456789876543210 a + type M3Sym0 :: forall a b. (~>) a ((~>) b (a, b)) + data M3Sym0 :: (~>) a ((~>) b (a, b)) + where + M3Sym0KindInference :: SameKind (Apply M3Sym0 arg) (M3Sym1 arg) => + M3Sym0 a0123456789876543210 + type instance Apply @a @((~>) b (a, + b)) M3Sym0 a0123456789876543210 = M3Sym1 a0123456789876543210 + instance SuppressUnusedWarnings M3Sym0 where + suppressUnusedWarnings = snd ((,) M3Sym0KindInference ()) + type M3Sym1 :: forall a b. a -> (~>) b (a, b) + data M3Sym1 (a0123456789876543210 :: a) :: (~>) b (a, b) + where + M3Sym1KindInference :: SameKind (Apply (M3Sym1 a0123456789876543210) arg) (M3Sym2 a0123456789876543210 arg) => + M3Sym1 a0123456789876543210 a0123456789876543210 + type instance Apply @b @(a, + b) (M3Sym1 a0123456789876543210) a0123456789876543210 = M3 a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (M3Sym1 a0123456789876543210) where + suppressUnusedWarnings = snd ((,) M3Sym1KindInference ()) + type M3Sym2 :: forall a b. a -> b -> (a, b) + type family M3Sym2 @a @b (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (a, + b) where + M3Sym2 a0123456789876543210 a0123456789876543210 = M3 a0123456789876543210 a0123456789876543210 + type M3_0123456789876543210 :: forall a b. a -> b -> (a, b) + type family M3_0123456789876543210 @a @b (a :: a) (a :: b) :: (a, + b) where + M3_0123456789876543210 @a @b (x :: a) (y :: b) = Apply (Apply Tuple2Sym0 x) y :: (a, + b) + class PC3 a where + type family M3 (arg :: a) (arg :: b) :: (a, b) + type M3 a a = M3_0123456789876543210 a a + type M1_0123456789876543210 :: forall a b. [a] -> Maybe ([a], b) + type family M1_0123456789876543210 @a @b (a :: [a]) :: Maybe ([a], + b) where + M1_0123456789876543210 @a @b (_ :: [a]) = NothingSym0 :: Maybe ([a], + b) + instance PC1 [a] where + type M1 a = M1_0123456789876543210 a + type M2_0123456789876543210 :: forall a b. b -> Maybe [a] + type family M2_0123456789876543210 @a @b (a :: b) :: Maybe [a] where + M2_0123456789876543210 @a @b (_ :: b) = NothingSym0 :: Maybe [a] + instance PC2 [a] where + type M2 a = M2_0123456789876543210 a + type M2_0123456789876543210 :: forall a b. b -> Maybe (Maybe a) + type family M2_0123456789876543210 @a @b (a :: b) :: Maybe (Maybe a) where + M2_0123456789876543210 @a @b (_ :: b) = NothingSym0 :: Maybe (Maybe a) + instance PC2 (Maybe a) where + type M2 a = M2_0123456789876543210 a + type family LamCases_0123456789876543210 a0123456789876543210 (x0123456789876543210 :: Maybe a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_0123456789876543210 where + LamCases_0123456789876543210 a x y xx = xx :: a + data LamCases_0123456789876543210Sym0 a0123456789876543210 (x0123456789876543210 :: Maybe a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 + where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 y0123456789876543210 arg) => + LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) where + suppressUnusedWarnings + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 a0123456789876543210 (x0123456789876543210 :: Maybe a0123456789876543210) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 + type M3_0123456789876543210 :: forall a b. Maybe a + -> b -> (Maybe a, b) + type family M3_0123456789876543210 @a @b (a :: Maybe a) (a :: b) :: (Maybe a, + b) where + M3_0123456789876543210 @a @b (x :: Maybe a) (y :: b) = Apply (Apply Tuple2Sym0 (Apply (Apply FmapSym0 (LamCases_0123456789876543210Sym0 a x y)) x)) y + instance PC3 (Maybe a) where + type M3 a a = M3_0123456789876543210 a a + type family LamCases_0123456789876543210 a0123456789876543210 (x0123456789876543210 :: [a0123456789876543210]) (y0123456789876543210 :: b0123456789876543210) a_0123456789876543210 where + LamCases_0123456789876543210 a x y xx = xx :: a + data LamCases_0123456789876543210Sym0 a0123456789876543210 (x0123456789876543210 :: [a0123456789876543210]) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 + where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) arg) (LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 y0123456789876543210 arg) => + LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 a0123456789876543210 x0123456789876543210 y0123456789876543210) where + suppressUnusedWarnings + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 a0123456789876543210 (x0123456789876543210 :: [a0123456789876543210]) (y0123456789876543210 :: b0123456789876543210) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 a0123456789876543210 x0123456789876543210 y0123456789876543210 a_01234567898765432100123456789876543210 + type M3_0123456789876543210 :: forall a b. [a] -> b -> ([a], b) + type family M3_0123456789876543210 @a @b (a :: [a]) (a :: b) :: ([a], + b) where + M3_0123456789876543210 @a @b (x :: [a]) (y :: b) = Apply (Apply Tuple2Sym0 (Apply (Apply FmapSym0 (LamCases_0123456789876543210Sym0 a x y)) x)) y + instance PC3 [a] where + type M3 a a = M3_0123456789876543210 a a + class SC1 a where + sM1 :: forall b (t :: a). Sing t -> Sing (M1 t :: Maybe (a, b)) + default sM1 :: + forall b (t :: a). ((M1 t :: Maybe (a, b)) + ~ M1_0123456789876543210 t) => + Sing t -> Sing (M1 t :: Maybe (a, b)) + sM1 _ = SNothing :: Sing (NothingSym0 :: Maybe (a, b)) + class SC2 a where + sM2 :: (forall (t :: b). Sing t -> Sing (M2 t :: Maybe a) :: Type) + default sM2 :: + (forall (t :: b). + ((M2 t :: Maybe a) ~ M2_0123456789876543210 t) => + Sing t -> Sing (M2 t :: Maybe a) :: Type) + sM2 _ = SNothing :: Sing (NothingSym0 :: Maybe a) + class SC3 a where + sM3 :: + forall b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (M3 t t :: (a, b)) + default sM3 :: + forall b (t :: a) (t :: b). ((M3 t t :: (a, b)) + ~ M3_0123456789876543210 t t) => + Sing t -> Sing t -> Sing (M3 t t :: (a, b)) + sM3 (sX :: Sing x) (sY :: Sing y) + = applySing (applySing (singFun2 @Tuple2Sym0 STuple2) sX) sY :: + Sing (Apply (Apply Tuple2Sym0 x) y :: (a, b)) + instance SC1 [a] where + sM1 :: forall b (t :: [a]). Sing t -> Sing (M1 t :: Maybe ([a], b)) + sM1 _ = SNothing :: Sing (NothingSym0 :: Maybe ([a], b)) + instance SC2 [a] where + sM2 :: + (forall (t :: b). Sing t -> Sing (M2 t :: Maybe [a]) :: Type) + sM2 _ = SNothing :: Sing (NothingSym0 :: Maybe [a]) + instance SC2 (Maybe a) where + sM2 _ = SNothing :: Sing (NothingSym0 :: Maybe (Maybe a)) + instance SC3 (Maybe a) where + sM3 :: + (forall (t :: Maybe a) (t :: b). + Sing t -> Sing t -> Sing (M3 t t :: (Maybe a, b)) :: Type) + sM3 (sX :: Sing x) (sY :: Sing y) + = applySing + (applySing + (singFun2 @Tuple2Sym0 STuple2) + (applySing + (applySing + (singFun2 @FmapSym0 sFmap) + (singFun1 + @(LamCases_0123456789876543210Sym0 a x y) + (\cases (sXx :: Sing xx) -> sXx :: Sing (xx :: a)))) + sX)) + sY + instance SC3 [a] where + sM3 (sX :: Sing x) (sY :: Sing y) + = applySing + (applySing + (singFun2 @Tuple2Sym0 STuple2) + (applySing + (applySing + (singFun2 @FmapSym0 sFmap) + (singFun1 + @(LamCases_0123456789876543210Sym0 a x y) + (\cases (sXx :: Sing xx) -> sXx :: Sing (xx :: a)))) + sX)) + sY + instance SC1 a => SingI (M1Sym0 :: (~>) a (Maybe (a, b))) where + sing = singFun1 @M1Sym0 sM1 + instance SC2 a => SingI (M2Sym0 :: (~>) b (Maybe a)) where + sing = singFun1 @M2Sym0 sM2 + instance SC3 a => SingI (M3Sym0 :: (~>) a ((~>) b (a, b))) where + sing = singFun2 @M3Sym0 sM3 + instance (SC3 a, SingI d) => + SingI (M3Sym1 (d :: a) :: (~>) b (a, b)) where + sing = singFun1 @(M3Sym1 (d :: a)) (sM3 (sing @d)) + instance SC3 a => SingI1 (M3Sym1 :: a -> (~>) b (a, b)) where + liftSing (s :: Sing (d :: a)) = singFun1 @(M3Sym1 (d :: a)) (sM3 s) diff --git a/tests/compile-and-dump/Singletons/T581.hs b/tests/compile-and-dump/Singletons/T581.hs new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T581.hs @@ -0,0 +1,36 @@ +module T581 where + +import Data.Singletons.Base.TH +import Prelude.Singletons + +$(singletons + [d| class C1 a where + m1 :: forall b. a -> Maybe (a, b) + m1 _ = Nothing :: Maybe (a, b) + + instance C1 [a] where + m1 :: forall b. [a] -> Maybe ([a], b) + m1 _ = Nothing :: Maybe ([a], b) + + class C2 a where + m2 :: b -> Maybe a + m2 _ = Nothing :: Maybe a + + instance C2 [a] where + m2 :: b -> Maybe [a] + m2 _ = Nothing :: Maybe [a] + + instance C2 (Maybe a) where + m2 _ = Nothing :: Maybe (Maybe a) + + class C3 a where + m3 :: forall b. a -> b -> (a, b) + m3 x y = (x, y) :: (a, b) + + instance C3 (Maybe a) where + m3 :: Maybe a -> b -> (Maybe a, b) + m3 x y = (fmap (\xx -> (xx :: a)) x, y) + + instance C3 [a] where + m3 x y = (fmap (\xx -> (xx :: a)) x, y) + |]) diff --git a/tests/compile-and-dump/Singletons/T582.golden b/tests/compile-and-dump/Singletons/T582.golden new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T582.golden @@ -0,0 +1,150 @@ +Singletons/T582.hs:(0,0)-(0,0): Splicing declarations + singletons + [d| infixl 4 type !!! + infixl 4 data %%% + infixl 4 type `Bar` + infixl 4 data `foo` + + foo :: a -> a -> a + x `foo` _ = x + (%%%) :: a -> a -> a + x %%% _ = x + + type Bar :: a -> a -> a + type (!!!) :: a -> a -> a + + type x `Bar` y = x + type x !!! y = x |] + ======> + infixl 4 data `foo` + foo :: a -> a -> a + foo x _ = x + infixl 4 type `Bar` + type Bar :: a -> a -> a + type Bar x y = x + infixl 4 data %%% + (%%%) :: a -> a -> a + (%%%) x _ = x + infixl 4 type !!! + type (!!!) :: a -> a -> a + type (!!!) x y = x + type BarSym0 :: (~>) a ((~>) a a) + data BarSym0 :: (~>) a ((~>) a a) + where + BarSym0KindInference :: SameKind (Apply BarSym0 arg) (BarSym1 arg) => + BarSym0 a0123456789876543210 + type instance Apply @a @((~>) a a) BarSym0 a0123456789876543210 = BarSym1 a0123456789876543210 + instance SuppressUnusedWarnings BarSym0 where + suppressUnusedWarnings = snd ((,) BarSym0KindInference ()) + infixl 4 type `BarSym0` + type BarSym1 :: a -> (~>) a a + data BarSym1 (a0123456789876543210 :: a) :: (~>) a a + where + BarSym1KindInference :: SameKind (Apply (BarSym1 a0123456789876543210) arg) (BarSym2 a0123456789876543210 arg) => + BarSym1 a0123456789876543210 a0123456789876543210 + type instance Apply @a @a (BarSym1 a0123456789876543210) a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (BarSym1 a0123456789876543210) where + suppressUnusedWarnings = snd ((,) BarSym1KindInference ()) + infixl 4 type `BarSym1` + type BarSym2 :: a -> a -> a + type family BarSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where + BarSym2 a0123456789876543210 a0123456789876543210 = Bar a0123456789876543210 a0123456789876543210 + infixl 4 type `BarSym2` + type (!!!@#@$) :: (~>) a ((~>) a a) + data (!!!@#@$) :: (~>) a ((~>) a a) + where + (:!!!@#@$###) :: SameKind (Apply (!!!@#@$) arg) ((!!!@#@$$) arg) => + (!!!@#@$) a0123456789876543210 + type instance Apply @a @((~>) a a) (!!!@#@$) a0123456789876543210 = (!!!@#@$$) a0123456789876543210 + instance SuppressUnusedWarnings (!!!@#@$) where + suppressUnusedWarnings = snd ((,) (:!!!@#@$###) ()) + infixl 4 type !!!@#@$ + type (!!!@#@$$) :: a -> (~>) a a + data (!!!@#@$$) (a0123456789876543210 :: a) :: (~>) a a + where + (:!!!@#@$$###) :: SameKind (Apply ((!!!@#@$$) a0123456789876543210) arg) ((!!!@#@$$$) a0123456789876543210 arg) => + (!!!@#@$$) a0123456789876543210 a0123456789876543210 + type instance Apply @a @a ((!!!@#@$$) a0123456789876543210) a0123456789876543210 = (!!!) a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings ((!!!@#@$$) a0123456789876543210) where + suppressUnusedWarnings = snd ((,) (:!!!@#@$$###) ()) + infixl 4 type !!!@#@$$ + type (!!!@#@$$$) :: a -> a -> a + type family (!!!@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where + (!!!@#@$$$) a0123456789876543210 a0123456789876543210 = (!!!) a0123456789876543210 a0123456789876543210 + infixl 4 type !!!@#@$$$ + type (%%%@#@$) :: (~>) a ((~>) a a) + data (%%%@#@$) :: (~>) a ((~>) a a) + where + (:%%%@#@$###) :: SameKind (Apply (%%%@#@$) arg) ((%%%@#@$$) arg) => + (%%%@#@$) a0123456789876543210 + type instance Apply @a @((~>) a a) (%%%@#@$) a0123456789876543210 = (%%%@#@$$) a0123456789876543210 + instance SuppressUnusedWarnings (%%%@#@$) where + suppressUnusedWarnings = snd ((,) (:%%%@#@$###) ()) + infixl 4 type %%%@#@$ + type (%%%@#@$$) :: a -> (~>) a a + data (%%%@#@$$) (a0123456789876543210 :: a) :: (~>) a a + where + (:%%%@#@$$###) :: SameKind (Apply ((%%%@#@$$) a0123456789876543210) arg) ((%%%@#@$$$) a0123456789876543210 arg) => + (%%%@#@$$) a0123456789876543210 a0123456789876543210 + type instance Apply @a @a ((%%%@#@$$) a0123456789876543210) a0123456789876543210 = (%%%) a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings ((%%%@#@$$) a0123456789876543210) where + suppressUnusedWarnings = snd ((,) (:%%%@#@$$###) ()) + infixl 4 type %%%@#@$$ + type (%%%@#@$$$) :: a -> a -> a + type family (%%%@#@$$$) @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where + (%%%@#@$$$) a0123456789876543210 a0123456789876543210 = (%%%) a0123456789876543210 a0123456789876543210 + infixl 4 type %%%@#@$$$ + type FooSym0 :: (~>) a ((~>) a a) + data FooSym0 :: (~>) a ((~>) a a) + where + FooSym0KindInference :: SameKind (Apply FooSym0 arg) (FooSym1 arg) => + FooSym0 a0123456789876543210 + type instance Apply @a @((~>) a a) FooSym0 a0123456789876543210 = FooSym1 a0123456789876543210 + instance SuppressUnusedWarnings FooSym0 where + suppressUnusedWarnings = snd ((,) FooSym0KindInference ()) + infixl 4 type `FooSym0` + type FooSym1 :: a -> (~>) a a + data FooSym1 (a0123456789876543210 :: a) :: (~>) a a + where + FooSym1KindInference :: SameKind (Apply (FooSym1 a0123456789876543210) arg) (FooSym2 a0123456789876543210 arg) => + FooSym1 a0123456789876543210 a0123456789876543210 + type instance Apply @a @a (FooSym1 a0123456789876543210) a0123456789876543210 = Foo a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (FooSym1 a0123456789876543210) where + suppressUnusedWarnings = snd ((,) FooSym1KindInference ()) + infixl 4 type `FooSym1` + type FooSym2 :: a -> a -> a + type family FooSym2 @a (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where + FooSym2 a0123456789876543210 a0123456789876543210 = Foo a0123456789876543210 a0123456789876543210 + infixl 4 type `FooSym2` + type (%%%) :: a -> a -> a + type family (%%%) @a (a :: a) (a :: a) :: a where + (%%%) x _ = x + type Foo :: a -> a -> a + type family Foo @a (a :: a) (a :: a) :: a where + Foo x _ = x + infixl 4 type %%% + infixl 4 type `Foo` + infixl 4 data %%%% + infixl 4 data `sFoo` + (%%%%) :: + (forall (t :: a) (t :: a). + Sing t -> Sing t -> Sing ((%%%) t t :: a) :: Type) + sFoo :: + (forall (t :: a) (t :: a). + Sing t -> Sing t -> Sing (Foo t t :: a) :: Type) + (%%%%) (sX :: Sing x) _ = sX + sFoo (sX :: Sing x) _ = sX + instance SingI ((%%%@#@$) :: (~>) a ((~>) a a)) where + sing = singFun2 @(%%%@#@$) (%%%%) + instance SingI d => SingI ((%%%@#@$$) (d :: a) :: (~>) a a) where + sing = singFun1 @((%%%@#@$$) (d :: a)) ((%%%%) (sing @d)) + instance SingI1 ((%%%@#@$$) :: a -> (~>) a a) where + liftSing (s :: Sing (d :: a)) + = singFun1 @((%%%@#@$$) (d :: a)) ((%%%%) s) + instance SingI (FooSym0 :: (~>) a ((~>) a a)) where + sing = singFun2 @FooSym0 sFoo + instance SingI d => SingI (FooSym1 (d :: a) :: (~>) a a) where + sing = singFun1 @(FooSym1 (d :: a)) (sFoo (sing @d)) + instance SingI1 (FooSym1 :: a -> (~>) a a) where + liftSing (s :: Sing (d :: a)) + = singFun1 @(FooSym1 (d :: a)) (sFoo s) diff --git a/tests/compile-and-dump/Singletons/T582.hs b/tests/compile-and-dump/Singletons/T582.hs new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T582.hs @@ -0,0 +1,21 @@ +module T582 where + +import Data.Singletons.TH + +$(singletons [d| + infixl 4 data `foo` + foo :: a -> a -> a + x `foo` _ = x + + infixl 4 type `Bar` + type Bar :: a -> a -> a + type x `Bar` y = x + + infixl 4 data %%% + (%%%) :: a -> a -> a + x %%% _ = x + + infixl 4 type !!! + type (!!!) :: a -> a -> a + type x !!! y = x + |]) diff --git a/tests/compile-and-dump/Singletons/T585.golden b/tests/compile-and-dump/Singletons/T585.golden --- a/tests/compile-and-dump/Singletons/T585.golden +++ b/tests/compile-and-dump/Singletons/T585.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/T78.golden b/tests/compile-and-dump/Singletons/T78.golden --- a/tests/compile-and-dump/Singletons/T78.golden +++ b/tests/compile-and-dump/Singletons/T78.golden @@ -14,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 diff --git a/tests/compile-and-dump/Singletons/T89.golden b/tests/compile-and-dump/Singletons/T89.golden --- a/tests/compile-and-dump/Singletons/T89.golden +++ b/tests/compile-and-dump/Singletons/T89.golden @@ -10,44 +10,30 @@ 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.Internal.Bignum.Natural.Natural) a_0123456789876543210 where + LamCases_0123456789876543210 n 'True = FooSym0 + LamCases_0123456789876543210 n 'False = Apply ErrorSym0 (FromString "toEnum: bad argument") + data LamCases_0123456789876543210Sym0 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where - ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) => - ToEnum_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where + LamCases_0123456789876543210Sym0KindInference :: SameKind (Apply (LamCases_0123456789876543210Sym0 n0123456789876543210) arg) (LamCases_0123456789876543210Sym1 n0123456789876543210 arg) => + LamCases_0123456789876543210Sym0 n0123456789876543210 a_01234567898765432100123456789876543210 + type instance Apply @_ @_ (LamCases_0123456789876543210Sym0 n0123456789876543210) a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + instance SuppressUnusedWarnings (LamCases_0123456789876543210Sym0 n0123456789876543210) where suppressUnusedWarnings - = snd ((,) ToEnum_0123456789876543210Sym0KindInference ()) - type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural - -> Foo - type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: Foo where - ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - type FromEnum_0123456789876543210 :: Foo -> GHC.Num.Natural.Natural - type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Num.Natural.Natural where + = snd ((,) LamCases_0123456789876543210Sym0KindInference ()) + type family LamCases_0123456789876543210Sym1 (n0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural) a_01234567898765432100123456789876543210 where + LamCases_0123456789876543210Sym1 n0123456789876543210 a_01234567898765432100123456789876543210 = LamCases_0123456789876543210 n0123456789876543210 a_01234567898765432100123456789876543210 + type ToEnum_0123456789876543210 :: GHC.Internal.Bignum.Natural.Natural + -> Foo + type family ToEnum_0123456789876543210 (a :: GHC.Internal.Bignum.Natural.Natural) :: Foo where + ToEnum_0123456789876543210 n = Apply (LamCases_0123456789876543210Sym0 n) (Apply (Apply (==@#@$) n) (FromInteger 0)) + type FromEnum_0123456789876543210 :: Foo + -> GHC.Internal.Bignum.Natural.Natural + type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Internal.Bignum.Natural.Natural where FromEnum_0123456789876543210 Foo = FromInteger 0 - 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 +41,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 diff --git a/tests/compile-and-dump/Singletons/TopLevelPatterns.golden b/tests/compile-and-dump/Singletons/TopLevelPatterns.golden --- a/tests/compile-and-dump/Singletons/TopLevelPatterns.golden +++ b/tests/compile-and-dump/Singletons/TopLevelPatterns.golden @@ -16,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 diff --git a/tests/compile-and-dump/Singletons/TypeAbstractions.golden b/tests/compile-and-dump/Singletons/TypeAbstractions.golden --- a/tests/compile-and-dump/Singletons/TypeAbstractions.golden +++ b/tests/compile-and-dump/Singletons/TypeAbstractions.golden @@ -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 diff --git a/tests/compile-and-dump/Singletons/Undef.golden b/tests/compile-and-dump/Singletons/Undef.golden --- a/tests/compile-and-dump/Singletons/Undef.golden +++ b/tests/compile-and-dump/Singletons/Undef.golden @@ -14,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